// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/redis/go-redis/v9 (interfaces: Cmdable,UniversalClient)
//
// Generated by this command:
//
//	mockgen -destination=../../mocks/github.com/redis/go-redis/v9/cmdable.go github.com/redis/go-redis/v9 Cmdable,UniversalClient
//

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

import (
	context "context"
	reflect "reflect"
	time "time"

	redis "github.com/redis/go-redis/v9"
	gomock "go.uber.org/mock/gomock"
)

// MockCmdable is a mock of Cmdable interface.
type MockCmdable struct {
	ctrl     *gomock.Controller
	recorder *MockCmdableMockRecorder
	isgomock struct{}
}

// MockCmdableMockRecorder is the mock recorder for MockCmdable.
type MockCmdableMockRecorder struct {
	mock *MockCmdable
}

// NewMockCmdable creates a new mock instance.
func NewMockCmdable(ctrl *gomock.Controller) *MockCmdable {
	mock := &MockCmdable{ctrl: ctrl}
	mock.recorder = &MockCmdableMockRecorder{mock}
	return mock
}

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

// ACLCat mocks base method.
func (m *MockCmdable) ACLCat(ctx context.Context) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLCat", ctx)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ACLCat indicates an expected call of ACLCat.
func (mr *MockCmdableMockRecorder) ACLCat(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLCat", reflect.TypeOf((*MockCmdable)(nil).ACLCat), ctx)
}

// ACLCatArgs mocks base method.
func (m *MockCmdable) ACLCatArgs(ctx context.Context, options *redis.ACLCatArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLCatArgs", ctx, options)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ACLCatArgs indicates an expected call of ACLCatArgs.
func (mr *MockCmdableMockRecorder) ACLCatArgs(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLCatArgs", reflect.TypeOf((*MockCmdable)(nil).ACLCatArgs), ctx, options)
}

// ACLDelUser mocks base method.
func (m *MockCmdable) ACLDelUser(ctx context.Context, username string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLDelUser", ctx, username)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ACLDelUser indicates an expected call of ACLDelUser.
func (mr *MockCmdableMockRecorder) ACLDelUser(ctx, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDelUser", reflect.TypeOf((*MockCmdable)(nil).ACLDelUser), ctx, username)
}

// ACLDryRun mocks base method.
func (m *MockCmdable) ACLDryRun(ctx context.Context, username string, command ...any) *redis.StringCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, username}
	for _, a := range command {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ACLDryRun", varargs...)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ACLDryRun indicates an expected call of ACLDryRun.
func (mr *MockCmdableMockRecorder) ACLDryRun(ctx, username any, command ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, username}, command...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockCmdable)(nil).ACLDryRun), varargs...)
}

// ACLList mocks base method.
func (m *MockCmdable) ACLList(ctx context.Context) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLList", ctx)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ACLList indicates an expected call of ACLList.
func (mr *MockCmdableMockRecorder) ACLList(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLList", reflect.TypeOf((*MockCmdable)(nil).ACLList), ctx)
}

// ACLLog mocks base method.
func (m *MockCmdable) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLLog", ctx, count)
	ret0, _ := ret[0].(*redis.ACLLogCmd)
	return ret0
}

// ACLLog indicates an expected call of ACLLog.
func (mr *MockCmdableMockRecorder) ACLLog(ctx, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockCmdable)(nil).ACLLog), ctx, count)
}

// ACLLogReset mocks base method.
func (m *MockCmdable) ACLLogReset(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLLogReset", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ACLLogReset indicates an expected call of ACLLogReset.
func (mr *MockCmdableMockRecorder) ACLLogReset(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockCmdable)(nil).ACLLogReset), ctx)
}

// ACLSetUser mocks base method.
func (m *MockCmdable) ACLSetUser(ctx context.Context, username string, rules ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, username}
	for _, a := range rules {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ACLSetUser", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ACLSetUser indicates an expected call of ACLSetUser.
func (mr *MockCmdableMockRecorder) ACLSetUser(ctx, username any, rules ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, username}, rules...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLSetUser", reflect.TypeOf((*MockCmdable)(nil).ACLSetUser), varargs...)
}

// Append mocks base method.
func (m *MockCmdable) Append(ctx context.Context, key, value string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Append", ctx, key, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Append indicates an expected call of Append.
func (mr *MockCmdableMockRecorder) Append(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockCmdable)(nil).Append), ctx, key, value)
}

// BFAdd mocks base method.
func (m *MockCmdable) BFAdd(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFAdd", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// BFAdd indicates an expected call of BFAdd.
func (mr *MockCmdableMockRecorder) BFAdd(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockCmdable)(nil).BFAdd), ctx, key, element)
}

// BFCard mocks base method.
func (m *MockCmdable) BFCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// BFExists mocks base method.
func (m *MockCmdable) BFExists(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFExists", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// BFExists indicates an expected call of BFExists.
func (mr *MockCmdableMockRecorder) BFExists(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockCmdable)(nil).BFExists), ctx, key, element)
}

// BFInfo mocks base method.
func (m *MockCmdable) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfo", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoArg mocks base method.
func (m *MockCmdable) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

// BFInfoArg indicates an expected call of BFInfoArg.
func (mr *MockCmdableMockRecorder) BFInfoArg(ctx, key, option any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockCmdable)(nil).BFInfoArg), ctx, key, option)
}

// BFInfoCapacity mocks base method.
func (m *MockCmdable) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoExpansion mocks base method.
func (m *MockCmdable) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoFilters mocks base method.
func (m *MockCmdable) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoItems mocks base method.
func (m *MockCmdable) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoItems", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoSize mocks base method.
func (m *MockCmdable) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoSize", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInsert mocks base method.
func (m *MockCmdable) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BFInsert", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// BFInsert indicates an expected call of BFInsert.
func (mr *MockCmdableMockRecorder) BFInsert(ctx, key, options any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockCmdable)(nil).BFInsert), varargs...)
}

// BFLoadChunk mocks base method.
func (m *MockCmdable) BFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFLoadChunk indicates an expected call of BFLoadChunk.
func (mr *MockCmdableMockRecorder) BFLoadChunk(ctx, key, iterator, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).BFLoadChunk), ctx, key, iterator, data)
}

// BFMAdd mocks base method.
func (m *MockCmdable) BFMAdd(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BFMAdd", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// BFMAdd indicates an expected call of BFMAdd.
func (mr *MockCmdableMockRecorder) BFMAdd(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockCmdable)(nil).BFMAdd), varargs...)
}

// BFMExists mocks base method.
func (m *MockCmdable) BFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BFMExists", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// BFMExists indicates an expected call of BFMExists.
func (mr *MockCmdableMockRecorder) BFMExists(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockCmdable)(nil).BFMExists), varargs...)
}

// BFReserve mocks base method.
func (m *MockCmdable) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserve indicates an expected call of BFReserve.
func (mr *MockCmdableMockRecorder) BFReserve(ctx, key, errorRate, capacity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockCmdable)(nil).BFReserve), ctx, key, errorRate, capacity)
}

// BFReserveExpansion mocks base method.
func (m *MockCmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserveExpansion indicates an expected call of BFReserveExpansion.
func (mr *MockCmdableMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion)
}

// BFReserveNonScaling mocks base method.
func (m *MockCmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserveNonScaling indicates an expected call of BFReserveNonScaling.
func (mr *MockCmdableMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockCmdable)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity)
}

// BFReserveWithArgs mocks base method.
func (m *MockCmdable) BFReserveWithArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserveWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserveWithArgs indicates an expected call of BFReserveWithArgs.
func (mr *MockCmdableMockRecorder) BFReserveWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockCmdable)(nil).BFReserveWithArgs), ctx, key, options)
}

// BFScanDump mocks base method.
func (m *MockCmdable) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator)
	ret0, _ := ret[0].(*redis.ScanDumpCmd)
	return ret0
}

// BFScanDump indicates an expected call of BFScanDump.
func (mr *MockCmdableMockRecorder) BFScanDump(ctx, key, iterator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockCmdable)(nil).BFScanDump), ctx, key, iterator)
}

// BLMPop mocks base method.
func (m *MockCmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout, direction, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BLMPop", varargs...)
	ret0, _ := ret[0].(*redis.KeyValuesCmd)
	return ret0
}

// BLMPop indicates an expected call of BLMPop.
func (mr *MockCmdableMockRecorder) BLMPop(ctx, timeout, direction, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout, direction, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockCmdable)(nil).BLMPop), varargs...)
}

// BLMove mocks base method.
func (m *MockCmdable) BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// BLMove indicates an expected call of BLMove.
func (mr *MockCmdableMockRecorder) BLMove(ctx, source, destination, srcpos, destpos, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockCmdable)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout)
}

// BLPop mocks base method.
func (m *MockCmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BLPop", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// BLPop indicates an expected call of BLPop.
func (mr *MockCmdableMockRecorder) BLPop(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockCmdable)(nil).BLPop), varargs...)
}

// BRPop mocks base method.
func (m *MockCmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BRPop", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// BRPop indicates an expected call of BRPop.
func (mr *MockCmdableMockRecorder) BRPop(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockCmdable)(nil).BRPop), varargs...)
}

// BRPopLPush mocks base method.
func (m *MockCmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// BRPopLPush indicates an expected call of BRPopLPush.
func (mr *MockCmdableMockRecorder) BRPopLPush(ctx, source, destination, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockCmdable)(nil).BRPopLPush), ctx, source, destination, timeout)
}

// BZMPop mocks base method.
func (m *MockCmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout, order, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BZMPop", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd)
	return ret0
}

// BZMPop indicates an expected call of BZMPop.
func (mr *MockCmdableMockRecorder) BZMPop(ctx, timeout, order, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout, order, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockCmdable)(nil).BZMPop), varargs...)
}

// BZPopMax mocks base method.
func (m *MockCmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BZPopMax", varargs...)
	ret0, _ := ret[0].(*redis.ZWithKeyCmd)
	return ret0
}

// BZPopMax indicates an expected call of BZPopMax.
func (mr *MockCmdableMockRecorder) BZPopMax(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockCmdable)(nil).BZPopMax), varargs...)
}

// BZPopMin mocks base method.
func (m *MockCmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BZPopMin", varargs...)
	ret0, _ := ret[0].(*redis.ZWithKeyCmd)
	return ret0
}

// BZPopMin indicates an expected call of BZPopMin.
func (mr *MockCmdableMockRecorder) BZPopMin(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockCmdable)(nil).BZPopMin), varargs...)
}

// BgRewriteAOF mocks base method.
func (m *MockCmdable) BgRewriteAOF(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BgRewriteAOF", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BgRewriteAOF indicates an expected call of BgRewriteAOF.
func (mr *MockCmdableMockRecorder) BgRewriteAOF(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockCmdable)(nil).BgRewriteAOF), ctx)
}

// BgSave mocks base method.
func (m *MockCmdable) BgSave(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BgSave", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BgSave indicates an expected call of BgSave.
func (mr *MockCmdableMockRecorder) BgSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockCmdable)(nil).BgSave), ctx)
}

// BitCount mocks base method.
func (m *MockCmdable) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BitCount", ctx, key, bitCount)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitCount indicates an expected call of BitCount.
func (mr *MockCmdableMockRecorder) BitCount(ctx, key, bitCount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockCmdable)(nil).BitCount), ctx, key, bitCount)
}

// BitField mocks base method.
func (m *MockCmdable) BitField(ctx context.Context, key string, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitField", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// BitField indicates an expected call of BitField.
func (mr *MockCmdableMockRecorder) BitField(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockCmdable)(nil).BitField), varargs...)
}

// BitFieldRO mocks base method.
func (m *MockCmdable) BitFieldRO(ctx context.Context, key string, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitFieldRO", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// BitFieldRO indicates an expected call of BitFieldRO.
func (mr *MockCmdableMockRecorder) BitFieldRO(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitFieldRO", reflect.TypeOf((*MockCmdable)(nil).BitFieldRO), varargs...)
}

// BitOpAnd mocks base method.
func (m *MockCmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpAnd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpAnd indicates an expected call of BitOpAnd.
func (mr *MockCmdableMockRecorder) BitOpAnd(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockCmdable)(nil).BitOpAnd), varargs...)
}

// BitOpAndOr mocks base method.
func (m *MockCmdable) BitOpAndOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpAndOr", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpAndOr indicates an expected call of BitOpAndOr.
func (mr *MockCmdableMockRecorder) BitOpAndOr(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAndOr", reflect.TypeOf((*MockCmdable)(nil).BitOpAndOr), varargs...)
}

// BitOpDiff mocks base method.
func (m *MockCmdable) BitOpDiff(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpDiff", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpDiff indicates an expected call of BitOpDiff.
func (mr *MockCmdableMockRecorder) BitOpDiff(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpDiff", reflect.TypeOf((*MockCmdable)(nil).BitOpDiff), varargs...)
}

// BitOpDiff1 mocks base method.
func (m *MockCmdable) BitOpDiff1(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpDiff1", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpDiff1 indicates an expected call of BitOpDiff1.
func (mr *MockCmdableMockRecorder) BitOpDiff1(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpDiff1", reflect.TypeOf((*MockCmdable)(nil).BitOpDiff1), varargs...)
}

// BitOpNot mocks base method.
func (m *MockCmdable) BitOpNot(ctx context.Context, destKey, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BitOpNot", ctx, destKey, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpNot indicates an expected call of BitOpNot.
func (mr *MockCmdableMockRecorder) BitOpNot(ctx, destKey, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockCmdable)(nil).BitOpNot), ctx, destKey, key)
}

// BitOpOne mocks base method.
func (m *MockCmdable) BitOpOne(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpOne", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpOne indicates an expected call of BitOpOne.
func (mr *MockCmdableMockRecorder) BitOpOne(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOne", reflect.TypeOf((*MockCmdable)(nil).BitOpOne), varargs...)
}

// BitOpOr mocks base method.
func (m *MockCmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpOr", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpOr indicates an expected call of BitOpOr.
func (mr *MockCmdableMockRecorder) BitOpOr(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockCmdable)(nil).BitOpOr), varargs...)
}

// BitOpXor mocks base method.
func (m *MockCmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpXor", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpXor indicates an expected call of BitOpXor.
func (mr *MockCmdableMockRecorder) BitOpXor(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockCmdable)(nil).BitOpXor), varargs...)
}

// BitPos mocks base method.
func (m *MockCmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, bit}
	for _, a := range pos {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitPos", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitPos indicates an expected call of BitPos.
func (mr *MockCmdableMockRecorder) BitPos(ctx, key, bit any, pos ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, bit}, pos...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockCmdable)(nil).BitPos), varargs...)
}

// BitPosSpan mocks base method.
func (m *MockCmdable) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BitPosSpan", ctx, key, bit, start, end, span)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitPosSpan indicates an expected call of BitPosSpan.
func (mr *MockCmdableMockRecorder) BitPosSpan(ctx, key, bit, start, end, span any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockCmdable)(nil).BitPosSpan), ctx, key, bit, start, end, span)
}

// CFAdd mocks base method.
func (m *MockCmdable) CFAdd(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFAdd", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFAdd indicates an expected call of CFAdd.
func (mr *MockCmdableMockRecorder) CFAdd(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockCmdable)(nil).CFAdd), ctx, key, element)
}

// CFAddNX mocks base method.
func (m *MockCmdable) CFAddNX(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFAddNX indicates an expected call of CFAddNX.
func (mr *MockCmdableMockRecorder) CFAddNX(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockCmdable)(nil).CFAddNX), ctx, key, element)
}

// CFCount mocks base method.
func (m *MockCmdable) CFCount(ctx context.Context, key string, element any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFCount", ctx, key, element)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// CFCount indicates an expected call of CFCount.
func (mr *MockCmdableMockRecorder) CFCount(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockCmdable)(nil).CFCount), ctx, key, element)
}

// CFDel mocks base method.
func (m *MockCmdable) CFDel(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFDel", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFDel indicates an expected call of CFDel.
func (mr *MockCmdableMockRecorder) CFDel(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockCmdable)(nil).CFDel), ctx, key, element)
}

// CFExists mocks base method.
func (m *MockCmdable) CFExists(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFExists", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFExists indicates an expected call of CFExists.
func (mr *MockCmdableMockRecorder) CFExists(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockCmdable)(nil).CFExists), ctx, key, element)
}

// CFInfo mocks base method.
func (m *MockCmdable) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFInfo", ctx, key)
	ret0, _ := ret[0].(*redis.CFInfoCmd)
	return ret0
}

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

// CFInsert mocks base method.
func (m *MockCmdable) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CFInsert", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// CFInsert indicates an expected call of CFInsert.
func (mr *MockCmdableMockRecorder) CFInsert(ctx, key, options any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockCmdable)(nil).CFInsert), varargs...)
}

// CFInsertNX mocks base method.
func (m *MockCmdable) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CFInsertNX", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// CFInsertNX indicates an expected call of CFInsertNX.
func (mr *MockCmdableMockRecorder) CFInsertNX(ctx, key, options any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockCmdable)(nil).CFInsertNX), varargs...)
}

// CFLoadChunk mocks base method.
func (m *MockCmdable) CFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFLoadChunk indicates an expected call of CFLoadChunk.
func (mr *MockCmdableMockRecorder) CFLoadChunk(ctx, key, iterator, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).CFLoadChunk), ctx, key, iterator, data)
}

// CFMExists mocks base method.
func (m *MockCmdable) CFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CFMExists", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// CFMExists indicates an expected call of CFMExists.
func (mr *MockCmdableMockRecorder) CFMExists(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockCmdable)(nil).CFMExists), varargs...)
}

// CFReserve mocks base method.
func (m *MockCmdable) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserve indicates an expected call of CFReserve.
func (mr *MockCmdableMockRecorder) CFReserve(ctx, key, capacity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockCmdable)(nil).CFReserve), ctx, key, capacity)
}

// CFReserveBucketSize mocks base method.
func (m *MockCmdable) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveBucketSize indicates an expected call of CFReserveBucketSize.
func (mr *MockCmdableMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockCmdable)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize)
}

// CFReserveExpansion mocks base method.
func (m *MockCmdable) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveExpansion indicates an expected call of CFReserveExpansion.
func (mr *MockCmdableMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).CFReserveExpansion), ctx, key, capacity, expansion)
}

// CFReserveMaxIterations mocks base method.
func (m *MockCmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations.
func (mr *MockCmdableMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockCmdable)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations)
}

// CFReserveWithArgs mocks base method.
func (m *MockCmdable) CFReserveWithArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveWithArgs indicates an expected call of CFReserveWithArgs.
func (mr *MockCmdableMockRecorder) CFReserveWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockCmdable)(nil).CFReserveWithArgs), ctx, key, options)
}

// CFScanDump mocks base method.
func (m *MockCmdable) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator)
	ret0, _ := ret[0].(*redis.ScanDumpCmd)
	return ret0
}

// CFScanDump indicates an expected call of CFScanDump.
func (mr *MockCmdableMockRecorder) CFScanDump(ctx, key, iterator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockCmdable)(nil).CFScanDump), ctx, key, iterator)
}

// CMSIncrBy mocks base method.
func (m *MockCmdable) CMSIncrBy(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CMSIncrBy", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// CMSIncrBy indicates an expected call of CMSIncrBy.
func (mr *MockCmdableMockRecorder) CMSIncrBy(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockCmdable)(nil).CMSIncrBy), varargs...)
}

// CMSInfo mocks base method.
func (m *MockCmdable) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSInfo", ctx, key)
	ret0, _ := ret[0].(*redis.CMSInfoCmd)
	return ret0
}

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

// CMSInitByDim mocks base method.
func (m *MockCmdable) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSInitByDim indicates an expected call of CMSInitByDim.
func (mr *MockCmdableMockRecorder) CMSInitByDim(ctx, key, width, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockCmdable)(nil).CMSInitByDim), ctx, key, width, height)
}

// CMSInitByProb mocks base method.
func (m *MockCmdable) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSInitByProb indicates an expected call of CMSInitByProb.
func (mr *MockCmdableMockRecorder) CMSInitByProb(ctx, key, errorRate, probability any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockCmdable)(nil).CMSInitByProb), ctx, key, errorRate, probability)
}

// CMSMerge mocks base method.
func (m *MockCmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range sourceKeys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CMSMerge", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSMerge indicates an expected call of CMSMerge.
func (mr *MockCmdableMockRecorder) CMSMerge(ctx, destKey any, sourceKeys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, sourceKeys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockCmdable)(nil).CMSMerge), varargs...)
}

// CMSMergeWithWeight mocks base method.
func (m *MockCmdable) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight.
func (mr *MockCmdableMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockCmdable)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys)
}

// CMSQuery mocks base method.
func (m *MockCmdable) CMSQuery(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CMSQuery", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// CMSQuery indicates an expected call of CMSQuery.
func (mr *MockCmdableMockRecorder) CMSQuery(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockCmdable)(nil).CMSQuery), varargs...)
}

// ClientGetName mocks base method.
func (m *MockCmdable) ClientGetName(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientGetName", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClientGetName indicates an expected call of ClientGetName.
func (mr *MockCmdableMockRecorder) ClientGetName(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockCmdable)(nil).ClientGetName), ctx)
}

// ClientID mocks base method.
func (m *MockCmdable) ClientID(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientID", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientID indicates an expected call of ClientID.
func (mr *MockCmdableMockRecorder) ClientID(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockCmdable)(nil).ClientID), ctx)
}

// ClientInfo mocks base method.
func (m *MockCmdable) ClientInfo(ctx context.Context) *redis.ClientInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientInfo", ctx)
	ret0, _ := ret[0].(*redis.ClientInfoCmd)
	return ret0
}

// ClientInfo indicates an expected call of ClientInfo.
func (mr *MockCmdableMockRecorder) ClientInfo(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockCmdable)(nil).ClientInfo), ctx)
}

// ClientKill mocks base method.
func (m *MockCmdable) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClientKill indicates an expected call of ClientKill.
func (mr *MockCmdableMockRecorder) ClientKill(ctx, ipPort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockCmdable)(nil).ClientKill), ctx, ipPort)
}

// ClientKillByFilter mocks base method.
func (m *MockCmdable) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientKillByFilter indicates an expected call of ClientKillByFilter.
func (mr *MockCmdableMockRecorder) ClientKillByFilter(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockCmdable)(nil).ClientKillByFilter), varargs...)
}

// ClientList mocks base method.
func (m *MockCmdable) ClientList(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientList", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClientList indicates an expected call of ClientList.
func (mr *MockCmdableMockRecorder) ClientList(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockCmdable)(nil).ClientList), ctx)
}

// ClientPause mocks base method.
func (m *MockCmdable) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientPause", ctx, dur)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// ClientPause indicates an expected call of ClientPause.
func (mr *MockCmdableMockRecorder) ClientPause(ctx, dur any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockCmdable)(nil).ClientPause), ctx, dur)
}

// ClientUnblock mocks base method.
func (m *MockCmdable) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientUnblock", ctx, id)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientUnblock indicates an expected call of ClientUnblock.
func (mr *MockCmdableMockRecorder) ClientUnblock(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockCmdable)(nil).ClientUnblock), ctx, id)
}

// ClientUnblockWithError mocks base method.
func (m *MockCmdable) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientUnblockWithError indicates an expected call of ClientUnblockWithError.
func (mr *MockCmdableMockRecorder) ClientUnblockWithError(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockCmdable)(nil).ClientUnblockWithError), ctx, id)
}

// ClientUnpause mocks base method.
func (m *MockCmdable) ClientUnpause(ctx context.Context) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientUnpause", ctx)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// ClientUnpause indicates an expected call of ClientUnpause.
func (mr *MockCmdableMockRecorder) ClientUnpause(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockCmdable)(nil).ClientUnpause), ctx)
}

// ClusterAddSlots mocks base method.
func (m *MockCmdable) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range slots {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterAddSlots indicates an expected call of ClusterAddSlots.
func (mr *MockCmdableMockRecorder) ClusterAddSlots(ctx any, slots ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, slots...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlots), varargs...)
}

// ClusterAddSlotsRange mocks base method.
func (m *MockCmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange.
func (mr *MockCmdableMockRecorder) ClusterAddSlotsRange(ctx, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlotsRange), ctx, min, max)
}

// ClusterCountFailureReports mocks base method.
func (m *MockCmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports.
func (mr *MockCmdableMockRecorder) ClusterCountFailureReports(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockCmdable)(nil).ClusterCountFailureReports), ctx, nodeID)
}

// ClusterCountKeysInSlot mocks base method.
func (m *MockCmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot.
func (mr *MockCmdableMockRecorder) ClusterCountKeysInSlot(ctx, slot any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterCountKeysInSlot), ctx, slot)
}

// ClusterDelSlots mocks base method.
func (m *MockCmdable) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range slots {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterDelSlots indicates an expected call of ClusterDelSlots.
func (mr *MockCmdableMockRecorder) ClusterDelSlots(ctx any, slots ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, slots...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlots), varargs...)
}

// ClusterDelSlotsRange mocks base method.
func (m *MockCmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange.
func (mr *MockCmdableMockRecorder) ClusterDelSlotsRange(ctx, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlotsRange), ctx, min, max)
}

// ClusterFailover mocks base method.
func (m *MockCmdable) ClusterFailover(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterFailover", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterFailover indicates an expected call of ClusterFailover.
func (mr *MockCmdableMockRecorder) ClusterFailover(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockCmdable)(nil).ClusterFailover), ctx)
}

// ClusterForget mocks base method.
func (m *MockCmdable) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterForget indicates an expected call of ClusterForget.
func (mr *MockCmdableMockRecorder) ClusterForget(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockCmdable)(nil).ClusterForget), ctx, nodeID)
}

// ClusterGetKeysInSlot mocks base method.
func (m *MockCmdable) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot.
func (mr *MockCmdableMockRecorder) ClusterGetKeysInSlot(ctx, slot, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterGetKeysInSlot), ctx, slot, count)
}

// ClusterInfo mocks base method.
func (m *MockCmdable) ClusterInfo(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterInfo", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterInfo indicates an expected call of ClusterInfo.
func (mr *MockCmdableMockRecorder) ClusterInfo(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockCmdable)(nil).ClusterInfo), ctx)
}

// ClusterKeySlot mocks base method.
func (m *MockCmdable) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// ClusterLinks mocks base method.
func (m *MockCmdable) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterLinks", ctx)
	ret0, _ := ret[0].(*redis.ClusterLinksCmd)
	return ret0
}

// ClusterLinks indicates an expected call of ClusterLinks.
func (mr *MockCmdableMockRecorder) ClusterLinks(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockCmdable)(nil).ClusterLinks), ctx)
}

// ClusterMeet mocks base method.
func (m *MockCmdable) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterMeet indicates an expected call of ClusterMeet.
func (mr *MockCmdableMockRecorder) ClusterMeet(ctx, host, port any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockCmdable)(nil).ClusterMeet), ctx, host, port)
}

// ClusterMyID mocks base method.
func (m *MockCmdable) ClusterMyID(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterMyID", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterMyID indicates an expected call of ClusterMyID.
func (mr *MockCmdableMockRecorder) ClusterMyID(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyID", reflect.TypeOf((*MockCmdable)(nil).ClusterMyID), ctx)
}

// ClusterMyShardID mocks base method.
func (m *MockCmdable) ClusterMyShardID(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterMyShardID", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterMyShardID indicates an expected call of ClusterMyShardID.
func (mr *MockCmdableMockRecorder) ClusterMyShardID(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockCmdable)(nil).ClusterMyShardID), ctx)
}

// ClusterNodes mocks base method.
func (m *MockCmdable) ClusterNodes(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterNodes", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterNodes indicates an expected call of ClusterNodes.
func (mr *MockCmdableMockRecorder) ClusterNodes(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockCmdable)(nil).ClusterNodes), ctx)
}

// ClusterReplicate mocks base method.
func (m *MockCmdable) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterReplicate indicates an expected call of ClusterReplicate.
func (mr *MockCmdableMockRecorder) ClusterReplicate(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockCmdable)(nil).ClusterReplicate), ctx, nodeID)
}

// ClusterResetHard mocks base method.
func (m *MockCmdable) ClusterResetHard(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterResetHard", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterResetHard indicates an expected call of ClusterResetHard.
func (mr *MockCmdableMockRecorder) ClusterResetHard(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockCmdable)(nil).ClusterResetHard), ctx)
}

// ClusterResetSoft mocks base method.
func (m *MockCmdable) ClusterResetSoft(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterResetSoft", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterResetSoft indicates an expected call of ClusterResetSoft.
func (mr *MockCmdableMockRecorder) ClusterResetSoft(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockCmdable)(nil).ClusterResetSoft), ctx)
}

// ClusterSaveConfig mocks base method.
func (m *MockCmdable) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterSaveConfig indicates an expected call of ClusterSaveConfig.
func (mr *MockCmdableMockRecorder) ClusterSaveConfig(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockCmdable)(nil).ClusterSaveConfig), ctx)
}

// ClusterShards mocks base method.
func (m *MockCmdable) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterShards", ctx)
	ret0, _ := ret[0].(*redis.ClusterShardsCmd)
	return ret0
}

// ClusterShards indicates an expected call of ClusterShards.
func (mr *MockCmdableMockRecorder) ClusterShards(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockCmdable)(nil).ClusterShards), ctx)
}

// ClusterSlaves mocks base method.
func (m *MockCmdable) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ClusterSlaves indicates an expected call of ClusterSlaves.
func (mr *MockCmdableMockRecorder) ClusterSlaves(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockCmdable)(nil).ClusterSlaves), ctx, nodeID)
}

// ClusterSlots mocks base method.
func (m *MockCmdable) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterSlots", ctx)
	ret0, _ := ret[0].(*redis.ClusterSlotsCmd)
	return ret0
}

// ClusterSlots indicates an expected call of ClusterSlots.
func (mr *MockCmdableMockRecorder) ClusterSlots(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterSlots), ctx)
}

// Command mocks base method.
func (m *MockCmdable) Command(ctx context.Context) *redis.CommandsInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Command", ctx)
	ret0, _ := ret[0].(*redis.CommandsInfoCmd)
	return ret0
}

// Command indicates an expected call of Command.
func (mr *MockCmdableMockRecorder) Command(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockCmdable)(nil).Command), ctx)
}

// CommandGetKeys mocks base method.
func (m *MockCmdable) CommandGetKeys(ctx context.Context, commands ...any) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range commands {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommandGetKeys", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// CommandGetKeys indicates an expected call of CommandGetKeys.
func (mr *MockCmdableMockRecorder) CommandGetKeys(ctx any, commands ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, commands...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockCmdable)(nil).CommandGetKeys), varargs...)
}

// CommandGetKeysAndFlags mocks base method.
func (m *MockCmdable) CommandGetKeysAndFlags(ctx context.Context, commands ...any) *redis.KeyFlagsCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range commands {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...)
	ret0, _ := ret[0].(*redis.KeyFlagsCmd)
	return ret0
}

// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags.
func (mr *MockCmdableMockRecorder) CommandGetKeysAndFlags(ctx any, commands ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, commands...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockCmdable)(nil).CommandGetKeysAndFlags), varargs...)
}

// CommandList mocks base method.
func (m *MockCmdable) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommandList", ctx, filter)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// CommandList indicates an expected call of CommandList.
func (mr *MockCmdableMockRecorder) CommandList(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockCmdable)(nil).CommandList), ctx, filter)
}

// ConfigGet mocks base method.
func (m *MockCmdable) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter)
	ret0, _ := ret[0].(*redis.MapStringStringCmd)
	return ret0
}

// ConfigGet indicates an expected call of ConfigGet.
func (mr *MockCmdableMockRecorder) ConfigGet(ctx, parameter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockCmdable)(nil).ConfigGet), ctx, parameter)
}

// ConfigResetStat mocks base method.
func (m *MockCmdable) ConfigResetStat(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigResetStat", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ConfigResetStat indicates an expected call of ConfigResetStat.
func (mr *MockCmdableMockRecorder) ConfigResetStat(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockCmdable)(nil).ConfigResetStat), ctx)
}

// ConfigRewrite mocks base method.
func (m *MockCmdable) ConfigRewrite(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigRewrite", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ConfigRewrite indicates an expected call of ConfigRewrite.
func (mr *MockCmdableMockRecorder) ConfigRewrite(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockCmdable)(nil).ConfigRewrite), ctx)
}

// ConfigSet mocks base method.
func (m *MockCmdable) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ConfigSet indicates an expected call of ConfigSet.
func (mr *MockCmdableMockRecorder) ConfigSet(ctx, parameter, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockCmdable)(nil).ConfigSet), ctx, parameter, value)
}

// Copy mocks base method.
func (m *MockCmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Copy indicates an expected call of Copy.
func (mr *MockCmdableMockRecorder) Copy(ctx, sourceKey, destKey, db, replace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockCmdable)(nil).Copy), ctx, sourceKey, destKey, db, replace)
}

// DBSize mocks base method.
func (m *MockCmdable) DBSize(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DBSize", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// DBSize indicates an expected call of DBSize.
func (mr *MockCmdableMockRecorder) DBSize(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockCmdable)(nil).DBSize), ctx)
}

// DebugObject mocks base method.
func (m *MockCmdable) DebugObject(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugObject", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// Decr mocks base method.
func (m *MockCmdable) Decr(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decr", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// DecrBy mocks base method.
func (m *MockCmdable) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// DecrBy indicates an expected call of DecrBy.
func (mr *MockCmdableMockRecorder) DecrBy(ctx, key, decrement any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockCmdable)(nil).DecrBy), ctx, key, decrement)
}

// Del mocks base method.
func (m *MockCmdable) Del(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Del", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Del indicates an expected call of Del.
func (mr *MockCmdableMockRecorder) Del(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockCmdable)(nil).Del), varargs...)
}

// Dump mocks base method.
func (m *MockCmdable) Dump(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Dump", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// Echo mocks base method.
func (m *MockCmdable) Echo(ctx context.Context, message any) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Echo", ctx, message)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// Echo indicates an expected call of Echo.
func (mr *MockCmdableMockRecorder) Echo(ctx, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockCmdable)(nil).Echo), ctx, message)
}

// Eval mocks base method.
func (m *MockCmdable) Eval(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, script, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Eval", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// Eval indicates an expected call of Eval.
func (mr *MockCmdableMockRecorder) Eval(ctx, script, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, script, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockCmdable)(nil).Eval), varargs...)
}

// EvalRO mocks base method.
func (m *MockCmdable) EvalRO(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, script, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvalRO", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// EvalRO indicates an expected call of EvalRO.
func (mr *MockCmdableMockRecorder) EvalRO(ctx, script, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, script, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockCmdable)(nil).EvalRO), varargs...)
}

// EvalSha mocks base method.
func (m *MockCmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, sha1, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvalSha", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// EvalSha indicates an expected call of EvalSha.
func (mr *MockCmdableMockRecorder) EvalSha(ctx, sha1, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, sha1, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockCmdable)(nil).EvalSha), varargs...)
}

// EvalShaRO mocks base method.
func (m *MockCmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, sha1, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvalShaRO", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// EvalShaRO indicates an expected call of EvalShaRO.
func (mr *MockCmdableMockRecorder) EvalShaRO(ctx, sha1, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, sha1, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockCmdable)(nil).EvalShaRO), varargs...)
}

// Exists mocks base method.
func (m *MockCmdable) Exists(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Exists", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Exists indicates an expected call of Exists.
func (mr *MockCmdableMockRecorder) Exists(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockCmdable)(nil).Exists), varargs...)
}

// Expire mocks base method.
func (m *MockCmdable) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expire", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireAt mocks base method.
func (m *MockCmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// ExpireAt indicates an expected call of ExpireAt.
func (mr *MockCmdableMockRecorder) ExpireAt(ctx, key, tm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockCmdable)(nil).ExpireAt), ctx, key, tm)
}

// ExpireGT mocks base method.
func (m *MockCmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireLT mocks base method.
func (m *MockCmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireNX mocks base method.
func (m *MockCmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireTime mocks base method.
func (m *MockCmdable) ExpireTime(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireTime", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// ExpireXX mocks base method.
func (m *MockCmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// FCall mocks base method.
func (m *MockCmdable) FCall(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, function, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FCall", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// FCall indicates an expected call of FCall.
func (mr *MockCmdableMockRecorder) FCall(ctx, function, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, function, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockCmdable)(nil).FCall), varargs...)
}

// FCallRO mocks base method.
func (m *MockCmdable) FCallRO(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, function, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FCallRO", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// FCallRO indicates an expected call of FCallRO.
func (mr *MockCmdableMockRecorder) FCallRO(ctx, function, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, function, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockCmdable)(nil).FCallRO), varargs...)
}

// FCallRo mocks base method.
func (m *MockCmdable) FCallRo(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, function, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FCallRo", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// FCallRo indicates an expected call of FCallRo.
func (mr *MockCmdableMockRecorder) FCallRo(ctx, function, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, function, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockCmdable)(nil).FCallRo), varargs...)
}

// FTAggregate mocks base method.
func (m *MockCmdable) FTAggregate(ctx context.Context, index, query string) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAggregate", ctx, index, query)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

// FTAggregate indicates an expected call of FTAggregate.
func (mr *MockCmdableMockRecorder) FTAggregate(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregate", reflect.TypeOf((*MockCmdable)(nil).FTAggregate), ctx, index, query)
}

// FTAggregateWithArgs mocks base method.
func (m *MockCmdable) FTAggregateWithArgs(ctx context.Context, index, query string, options *redis.FTAggregateOptions) *redis.AggregateCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAggregateWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.AggregateCmd)
	return ret0
}

// FTAggregateWithArgs indicates an expected call of FTAggregateWithArgs.
func (mr *MockCmdableMockRecorder) FTAggregateWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregateWithArgs", reflect.TypeOf((*MockCmdable)(nil).FTAggregateWithArgs), ctx, index, query, options)
}

// FTAliasAdd mocks base method.
func (m *MockCmdable) FTAliasAdd(ctx context.Context, index, alias string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAliasAdd", ctx, index, alias)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAliasAdd indicates an expected call of FTAliasAdd.
func (mr *MockCmdableMockRecorder) FTAliasAdd(ctx, index, alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasAdd", reflect.TypeOf((*MockCmdable)(nil).FTAliasAdd), ctx, index, alias)
}

// FTAliasDel mocks base method.
func (m *MockCmdable) FTAliasDel(ctx context.Context, alias string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAliasDel", ctx, alias)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAliasDel indicates an expected call of FTAliasDel.
func (mr *MockCmdableMockRecorder) FTAliasDel(ctx, alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasDel", reflect.TypeOf((*MockCmdable)(nil).FTAliasDel), ctx, alias)
}

// FTAliasUpdate mocks base method.
func (m *MockCmdable) FTAliasUpdate(ctx context.Context, index, alias string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAliasUpdate", ctx, index, alias)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAliasUpdate indicates an expected call of FTAliasUpdate.
func (mr *MockCmdableMockRecorder) FTAliasUpdate(ctx, index, alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasUpdate", reflect.TypeOf((*MockCmdable)(nil).FTAliasUpdate), ctx, index, alias)
}

// FTAlter mocks base method.
func (m *MockCmdable) FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAlter", ctx, index, skipInitialScan, definition)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAlter indicates an expected call of FTAlter.
func (mr *MockCmdableMockRecorder) FTAlter(ctx, index, skipInitialScan, definition any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAlter", reflect.TypeOf((*MockCmdable)(nil).FTAlter), ctx, index, skipInitialScan, definition)
}

// FTConfigGet mocks base method.
func (m *MockCmdable) FTConfigGet(ctx context.Context, option string) *redis.MapMapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTConfigGet", ctx, option)
	ret0, _ := ret[0].(*redis.MapMapStringInterfaceCmd)
	return ret0
}

// FTConfigGet indicates an expected call of FTConfigGet.
func (mr *MockCmdableMockRecorder) FTConfigGet(ctx, option any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigGet", reflect.TypeOf((*MockCmdable)(nil).FTConfigGet), ctx, option)
}

// FTConfigSet mocks base method.
func (m *MockCmdable) FTConfigSet(ctx context.Context, option string, value any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTConfigSet", ctx, option, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTConfigSet indicates an expected call of FTConfigSet.
func (mr *MockCmdableMockRecorder) FTConfigSet(ctx, option, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigSet", reflect.TypeOf((*MockCmdable)(nil).FTConfigSet), ctx, option, value)
}

// FTCreate mocks base method.
func (m *MockCmdable) FTCreate(ctx context.Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, index, options}
	for _, a := range schema {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FTCreate", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTCreate indicates an expected call of FTCreate.
func (mr *MockCmdableMockRecorder) FTCreate(ctx, index, options any, schema ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, index, options}, schema...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCreate", reflect.TypeOf((*MockCmdable)(nil).FTCreate), varargs...)
}

// FTCursorDel mocks base method.
func (m *MockCmdable) FTCursorDel(ctx context.Context, index string, cursorId int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTCursorDel", ctx, index, cursorId)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTCursorDel indicates an expected call of FTCursorDel.
func (mr *MockCmdableMockRecorder) FTCursorDel(ctx, index, cursorId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorDel", reflect.TypeOf((*MockCmdable)(nil).FTCursorDel), ctx, index, cursorId)
}

// FTCursorRead mocks base method.
func (m *MockCmdable) FTCursorRead(ctx context.Context, index string, cursorId, count int) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTCursorRead", ctx, index, cursorId, count)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

// FTCursorRead indicates an expected call of FTCursorRead.
func (mr *MockCmdableMockRecorder) FTCursorRead(ctx, index, cursorId, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorRead", reflect.TypeOf((*MockCmdable)(nil).FTCursorRead), ctx, index, cursorId, count)
}

// FTDictAdd mocks base method.
func (m *MockCmdable) FTDictAdd(ctx context.Context, dict string, term ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dict}
	for _, a := range term {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FTDictAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// FTDictAdd indicates an expected call of FTDictAdd.
func (mr *MockCmdableMockRecorder) FTDictAdd(ctx, dict any, term ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, dict}, term...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictAdd", reflect.TypeOf((*MockCmdable)(nil).FTDictAdd), varargs...)
}

// FTDictDel mocks base method.
func (m *MockCmdable) FTDictDel(ctx context.Context, dict string, term ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dict}
	for _, a := range term {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FTDictDel", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// FTDictDel indicates an expected call of FTDictDel.
func (mr *MockCmdableMockRecorder) FTDictDel(ctx, dict any, term ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, dict}, term...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDel", reflect.TypeOf((*MockCmdable)(nil).FTDictDel), varargs...)
}

// FTDictDump mocks base method.
func (m *MockCmdable) FTDictDump(ctx context.Context, dict string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTDictDump", ctx, dict)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// FTDictDump indicates an expected call of FTDictDump.
func (mr *MockCmdableMockRecorder) FTDictDump(ctx, dict any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDump", reflect.TypeOf((*MockCmdable)(nil).FTDictDump), ctx, dict)
}

// FTDropIndex mocks base method.
func (m *MockCmdable) FTDropIndex(ctx context.Context, index string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTDropIndex", ctx, index)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTDropIndex indicates an expected call of FTDropIndex.
func (mr *MockCmdableMockRecorder) FTDropIndex(ctx, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndex", reflect.TypeOf((*MockCmdable)(nil).FTDropIndex), ctx, index)
}

// FTDropIndexWithArgs mocks base method.
func (m *MockCmdable) FTDropIndexWithArgs(ctx context.Context, index string, options *redis.FTDropIndexOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTDropIndexWithArgs", ctx, index, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTDropIndexWithArgs indicates an expected call of FTDropIndexWithArgs.
func (mr *MockCmdableMockRecorder) FTDropIndexWithArgs(ctx, index, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndexWithArgs", reflect.TypeOf((*MockCmdable)(nil).FTDropIndexWithArgs), ctx, index, options)
}

// FTExplain mocks base method.
func (m *MockCmdable) FTExplain(ctx context.Context, index, query string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTExplain", ctx, index, query)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FTExplain indicates an expected call of FTExplain.
func (mr *MockCmdableMockRecorder) FTExplain(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplain", reflect.TypeOf((*MockCmdable)(nil).FTExplain), ctx, index, query)
}

// FTExplainWithArgs mocks base method.
func (m *MockCmdable) FTExplainWithArgs(ctx context.Context, index, query string, options *redis.FTExplainOptions) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTExplainWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FTExplainWithArgs indicates an expected call of FTExplainWithArgs.
func (mr *MockCmdableMockRecorder) FTExplainWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplainWithArgs", reflect.TypeOf((*MockCmdable)(nil).FTExplainWithArgs), ctx, index, query, options)
}

// FTInfo mocks base method.
func (m *MockCmdable) FTInfo(ctx context.Context, index string) *redis.FTInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTInfo", ctx, index)
	ret0, _ := ret[0].(*redis.FTInfoCmd)
	return ret0
}

// FTInfo indicates an expected call of FTInfo.
func (mr *MockCmdableMockRecorder) FTInfo(ctx, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTInfo", reflect.TypeOf((*MockCmdable)(nil).FTInfo), ctx, index)
}

// FTSearch mocks base method.
func (m *MockCmdable) FTSearch(ctx context.Context, index, query string) *redis.FTSearchCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSearch", ctx, index, query)
	ret0, _ := ret[0].(*redis.FTSearchCmd)
	return ret0
}

// FTSearch indicates an expected call of FTSearch.
func (mr *MockCmdableMockRecorder) FTSearch(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearch", reflect.TypeOf((*MockCmdable)(nil).FTSearch), ctx, index, query)
}

// FTSearchWithArgs mocks base method.
func (m *MockCmdable) FTSearchWithArgs(ctx context.Context, index, query string, options *redis.FTSearchOptions) *redis.FTSearchCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSearchWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.FTSearchCmd)
	return ret0
}

// FTSearchWithArgs indicates an expected call of FTSearchWithArgs.
func (mr *MockCmdableMockRecorder) FTSearchWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearchWithArgs", reflect.TypeOf((*MockCmdable)(nil).FTSearchWithArgs), ctx, index, query, options)
}

// FTSpellCheck mocks base method.
func (m *MockCmdable) FTSpellCheck(ctx context.Context, index, query string) *redis.FTSpellCheckCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSpellCheck", ctx, index, query)
	ret0, _ := ret[0].(*redis.FTSpellCheckCmd)
	return ret0
}

// FTSpellCheck indicates an expected call of FTSpellCheck.
func (mr *MockCmdableMockRecorder) FTSpellCheck(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheck", reflect.TypeOf((*MockCmdable)(nil).FTSpellCheck), ctx, index, query)
}

// FTSpellCheckWithArgs mocks base method.
func (m *MockCmdable) FTSpellCheckWithArgs(ctx context.Context, index, query string, options *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSpellCheckWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.FTSpellCheckCmd)
	return ret0
}

// FTSpellCheckWithArgs indicates an expected call of FTSpellCheckWithArgs.
func (mr *MockCmdableMockRecorder) FTSpellCheckWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheckWithArgs", reflect.TypeOf((*MockCmdable)(nil).FTSpellCheckWithArgs), ctx, index, query, options)
}

// FTSynDump mocks base method.
func (m *MockCmdable) FTSynDump(ctx context.Context, index string) *redis.FTSynDumpCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSynDump", ctx, index)
	ret0, _ := ret[0].(*redis.FTSynDumpCmd)
	return ret0
}

// FTSynDump indicates an expected call of FTSynDump.
func (mr *MockCmdableMockRecorder) FTSynDump(ctx, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynDump", reflect.TypeOf((*MockCmdable)(nil).FTSynDump), ctx, index)
}

// FTSynUpdate mocks base method.
func (m *MockCmdable) FTSynUpdate(ctx context.Context, index string, synGroupId any, terms []any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSynUpdate", ctx, index, synGroupId, terms)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTSynUpdate indicates an expected call of FTSynUpdate.
func (mr *MockCmdableMockRecorder) FTSynUpdate(ctx, index, synGroupId, terms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdate", reflect.TypeOf((*MockCmdable)(nil).FTSynUpdate), ctx, index, synGroupId, terms)
}

// FTSynUpdateWithArgs mocks base method.
func (m *MockCmdable) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId any, options *redis.FTSynUpdateOptions, terms []any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSynUpdateWithArgs", ctx, index, synGroupId, options, terms)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTSynUpdateWithArgs indicates an expected call of FTSynUpdateWithArgs.
func (mr *MockCmdableMockRecorder) FTSynUpdateWithArgs(ctx, index, synGroupId, options, terms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdateWithArgs", reflect.TypeOf((*MockCmdable)(nil).FTSynUpdateWithArgs), ctx, index, synGroupId, options, terms)
}

// FTTagVals mocks base method.
func (m *MockCmdable) FTTagVals(ctx context.Context, index, field string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTTagVals", ctx, index, field)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// FTTagVals indicates an expected call of FTTagVals.
func (mr *MockCmdableMockRecorder) FTTagVals(ctx, index, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTTagVals", reflect.TypeOf((*MockCmdable)(nil).FTTagVals), ctx, index, field)
}

// FT_List mocks base method.
func (m *MockCmdable) FT_List(ctx context.Context) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FT_List", ctx)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// FT_List indicates an expected call of FT_List.
func (mr *MockCmdableMockRecorder) FT_List(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FT_List", reflect.TypeOf((*MockCmdable)(nil).FT_List), ctx)
}

// FlushAll mocks base method.
func (m *MockCmdable) FlushAll(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushAll", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushAll indicates an expected call of FlushAll.
func (mr *MockCmdableMockRecorder) FlushAll(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockCmdable)(nil).FlushAll), ctx)
}

// FlushAllAsync mocks base method.
func (m *MockCmdable) FlushAllAsync(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushAllAsync", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushAllAsync indicates an expected call of FlushAllAsync.
func (mr *MockCmdableMockRecorder) FlushAllAsync(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockCmdable)(nil).FlushAllAsync), ctx)
}

// FlushDB mocks base method.
func (m *MockCmdable) FlushDB(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushDB", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushDB indicates an expected call of FlushDB.
func (mr *MockCmdableMockRecorder) FlushDB(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockCmdable)(nil).FlushDB), ctx)
}

// FlushDBAsync mocks base method.
func (m *MockCmdable) FlushDBAsync(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushDBAsync", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushDBAsync indicates an expected call of FlushDBAsync.
func (mr *MockCmdableMockRecorder) FlushDBAsync(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockCmdable)(nil).FlushDBAsync), ctx)
}

// FunctionDelete mocks base method.
func (m *MockCmdable) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionDelete indicates an expected call of FunctionDelete.
func (mr *MockCmdableMockRecorder) FunctionDelete(ctx, libName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockCmdable)(nil).FunctionDelete), ctx, libName)
}

// FunctionDump mocks base method.
func (m *MockCmdable) FunctionDump(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionDump", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionDump indicates an expected call of FunctionDump.
func (mr *MockCmdableMockRecorder) FunctionDump(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockCmdable)(nil).FunctionDump), ctx)
}

// FunctionFlush mocks base method.
func (m *MockCmdable) FunctionFlush(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionFlush", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionFlush indicates an expected call of FunctionFlush.
func (mr *MockCmdableMockRecorder) FunctionFlush(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockCmdable)(nil).FunctionFlush), ctx)
}

// FunctionFlushAsync mocks base method.
func (m *MockCmdable) FunctionFlushAsync(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionFlushAsync indicates an expected call of FunctionFlushAsync.
func (mr *MockCmdableMockRecorder) FunctionFlushAsync(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockCmdable)(nil).FunctionFlushAsync), ctx)
}

// FunctionKill mocks base method.
func (m *MockCmdable) FunctionKill(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionKill", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionKill indicates an expected call of FunctionKill.
func (mr *MockCmdableMockRecorder) FunctionKill(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockCmdable)(nil).FunctionKill), ctx)
}

// FunctionList mocks base method.
func (m *MockCmdable) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionList", ctx, q)
	ret0, _ := ret[0].(*redis.FunctionListCmd)
	return ret0
}

// FunctionList indicates an expected call of FunctionList.
func (mr *MockCmdableMockRecorder) FunctionList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockCmdable)(nil).FunctionList), ctx, q)
}

// FunctionLoad mocks base method.
func (m *MockCmdable) FunctionLoad(ctx context.Context, code string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionLoad", ctx, code)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionLoad indicates an expected call of FunctionLoad.
func (mr *MockCmdableMockRecorder) FunctionLoad(ctx, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockCmdable)(nil).FunctionLoad), ctx, code)
}

// FunctionLoadReplace mocks base method.
func (m *MockCmdable) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionLoadReplace indicates an expected call of FunctionLoadReplace.
func (mr *MockCmdableMockRecorder) FunctionLoadReplace(ctx, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockCmdable)(nil).FunctionLoadReplace), ctx, code)
}

// FunctionRestore mocks base method.
func (m *MockCmdable) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionRestore indicates an expected call of FunctionRestore.
func (mr *MockCmdableMockRecorder) FunctionRestore(ctx, libDump any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockCmdable)(nil).FunctionRestore), ctx, libDump)
}

// FunctionStats mocks base method.
func (m *MockCmdable) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionStats", ctx)
	ret0, _ := ret[0].(*redis.FunctionStatsCmd)
	return ret0
}

// FunctionStats indicates an expected call of FunctionStats.
func (mr *MockCmdableMockRecorder) FunctionStats(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockCmdable)(nil).FunctionStats), ctx)
}

// GeoAdd mocks base method.
func (m *MockCmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range geoLocation {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GeoAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoAdd indicates an expected call of GeoAdd.
func (mr *MockCmdableMockRecorder) GeoAdd(ctx, key any, geoLocation ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, geoLocation...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockCmdable)(nil).GeoAdd), varargs...)
}

// GeoDist mocks base method.
func (m *MockCmdable) GeoDist(ctx context.Context, key, member1, member2, unit string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// GeoDist indicates an expected call of GeoDist.
func (mr *MockCmdableMockRecorder) GeoDist(ctx, key, member1, member2, unit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockCmdable)(nil).GeoDist), ctx, key, member1, member2, unit)
}

// GeoHash mocks base method.
func (m *MockCmdable) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GeoHash", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// GeoHash indicates an expected call of GeoHash.
func (mr *MockCmdableMockRecorder) GeoHash(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockCmdable)(nil).GeoHash), varargs...)
}

// GeoPos mocks base method.
func (m *MockCmdable) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GeoPos", varargs...)
	ret0, _ := ret[0].(*redis.GeoPosCmd)
	return ret0
}

// GeoPos indicates an expected call of GeoPos.
func (mr *MockCmdableMockRecorder) GeoPos(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockCmdable)(nil).GeoPos), varargs...)
}

// GeoRadius mocks base method.
func (m *MockCmdable) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query)
	ret0, _ := ret[0].(*redis.GeoLocationCmd)
	return ret0
}

// GeoRadius indicates an expected call of GeoRadius.
func (mr *MockCmdableMockRecorder) GeoRadius(ctx, key, longitude, latitude, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockCmdable)(nil).GeoRadius), ctx, key, longitude, latitude, query)
}

// GeoRadiusByMember mocks base method.
func (m *MockCmdable) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query)
	ret0, _ := ret[0].(*redis.GeoLocationCmd)
	return ret0
}

// GeoRadiusByMember indicates an expected call of GeoRadiusByMember.
func (mr *MockCmdableMockRecorder) GeoRadiusByMember(ctx, key, member, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMember), ctx, key, member, query)
}

// GeoRadiusByMemberStore mocks base method.
func (m *MockCmdable) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore.
func (mr *MockCmdableMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMemberStore), ctx, key, member, query)
}

// GeoRadiusStore mocks base method.
func (m *MockCmdable) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoRadiusStore indicates an expected call of GeoRadiusStore.
func (mr *MockCmdableMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query)
}

// GeoSearch mocks base method.
func (m *MockCmdable) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// GeoSearch indicates an expected call of GeoSearch.
func (mr *MockCmdableMockRecorder) GeoSearch(ctx, key, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockCmdable)(nil).GeoSearch), ctx, key, q)
}

// GeoSearchLocation mocks base method.
func (m *MockCmdable) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q)
	ret0, _ := ret[0].(*redis.GeoSearchLocationCmd)
	return ret0
}

// GeoSearchLocation indicates an expected call of GeoSearchLocation.
func (mr *MockCmdableMockRecorder) GeoSearchLocation(ctx, key, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockCmdable)(nil).GeoSearchLocation), ctx, key, q)
}

// GeoSearchStore mocks base method.
func (m *MockCmdable) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoSearchStore indicates an expected call of GeoSearchStore.
func (mr *MockCmdableMockRecorder) GeoSearchStore(ctx, key, store, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockCmdable)(nil).GeoSearchStore), ctx, key, store, q)
}

// Get mocks base method.
func (m *MockCmdable) Get(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// GetBit mocks base method.
func (m *MockCmdable) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBit", ctx, key, offset)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GetBit indicates an expected call of GetBit.
func (mr *MockCmdableMockRecorder) GetBit(ctx, key, offset any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCmdable)(nil).GetBit), ctx, key, offset)
}

// GetDel mocks base method.
func (m *MockCmdable) GetDel(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDel", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// GetEx mocks base method.
func (m *MockCmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// GetRange mocks base method.
func (m *MockCmdable) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// GetRange indicates an expected call of GetRange.
func (mr *MockCmdableMockRecorder) GetRange(ctx, key, start, end any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCmdable)(nil).GetRange), ctx, key, start, end)
}

// GetSet mocks base method.
func (m *MockCmdable) GetSet(ctx context.Context, key string, value any) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSet", ctx, key, value)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// GetSet indicates an expected call of GetSet.
func (mr *MockCmdableMockRecorder) GetSet(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCmdable)(nil).GetSet), ctx, key, value)
}

// HDel mocks base method.
func (m *MockCmdable) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HDel", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HDel indicates an expected call of HDel.
func (mr *MockCmdableMockRecorder) HDel(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockCmdable)(nil).HDel), varargs...)
}

// HExists mocks base method.
func (m *MockCmdable) HExists(ctx context.Context, key, field string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HExists", ctx, key, field)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// HExists indicates an expected call of HExists.
func (mr *MockCmdableMockRecorder) HExists(ctx, key, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCmdable)(nil).HExists), ctx, key, field)
}

// HExpire mocks base method.
func (m *MockCmdable) HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpire", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpire indicates an expected call of HExpire.
func (mr *MockCmdableMockRecorder) HExpire(ctx, key, expiration any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpire", reflect.TypeOf((*MockCmdable)(nil).HExpire), varargs...)
}

// HExpireAt mocks base method.
func (m *MockCmdable) HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireAt", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireAt indicates an expected call of HExpireAt.
func (mr *MockCmdableMockRecorder) HExpireAt(ctx, key, tm any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAt", reflect.TypeOf((*MockCmdable)(nil).HExpireAt), varargs...)
}

// HExpireAtWithArgs mocks base method.
func (m *MockCmdable) HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireAtWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireAtWithArgs indicates an expected call of HExpireAtWithArgs.
func (mr *MockCmdableMockRecorder) HExpireAtWithArgs(ctx, key, tm, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAtWithArgs", reflect.TypeOf((*MockCmdable)(nil).HExpireAtWithArgs), varargs...)
}

// HExpireTime mocks base method.
func (m *MockCmdable) HExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireTime", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireTime indicates an expected call of HExpireTime.
func (mr *MockCmdableMockRecorder) HExpireTime(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireTime", reflect.TypeOf((*MockCmdable)(nil).HExpireTime), varargs...)
}

// HExpireWithArgs mocks base method.
func (m *MockCmdable) HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireWithArgs indicates an expected call of HExpireWithArgs.
func (mr *MockCmdableMockRecorder) HExpireWithArgs(ctx, key, expiration, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireWithArgs", reflect.TypeOf((*MockCmdable)(nil).HExpireWithArgs), varargs...)
}

// HGet mocks base method.
func (m *MockCmdable) HGet(ctx context.Context, key, field string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGet", ctx, key, field)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// HGet indicates an expected call of HGet.
func (mr *MockCmdableMockRecorder) HGet(ctx, key, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCmdable)(nil).HGet), ctx, key, field)
}

// HGetAll mocks base method.
func (m *MockCmdable) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGetAll", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringStringCmd)
	return ret0
}

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

// HGetDel mocks base method.
func (m *MockCmdable) HGetDel(ctx context.Context, key string, fields ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HGetDel", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HGetDel indicates an expected call of HGetDel.
func (mr *MockCmdableMockRecorder) HGetDel(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetDel", reflect.TypeOf((*MockCmdable)(nil).HGetDel), varargs...)
}

// HGetEX mocks base method.
func (m *MockCmdable) HGetEX(ctx context.Context, key string, fields ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HGetEX", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HGetEX indicates an expected call of HGetEX.
func (mr *MockCmdableMockRecorder) HGetEX(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetEX", reflect.TypeOf((*MockCmdable)(nil).HGetEX), varargs...)
}

// HGetEXWithArgs mocks base method.
func (m *MockCmdable) HGetEXWithArgs(ctx context.Context, key string, options *redis.HGetEXOptions, fields ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HGetEXWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HGetEXWithArgs indicates an expected call of HGetEXWithArgs.
func (mr *MockCmdableMockRecorder) HGetEXWithArgs(ctx, key, options any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetEXWithArgs", reflect.TypeOf((*MockCmdable)(nil).HGetEXWithArgs), varargs...)
}

// HIncrBy mocks base method.
func (m *MockCmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HIncrBy indicates an expected call of HIncrBy.
func (mr *MockCmdableMockRecorder) HIncrBy(ctx, key, field, incr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCmdable)(nil).HIncrBy), ctx, key, field, incr)
}

// HIncrByFloat mocks base method.
func (m *MockCmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// HIncrByFloat indicates an expected call of HIncrByFloat.
func (mr *MockCmdableMockRecorder) HIncrByFloat(ctx, key, field, incr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockCmdable)(nil).HIncrByFloat), ctx, key, field, incr)
}

// HKeys mocks base method.
func (m *MockCmdable) HKeys(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HKeys", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// HLen mocks base method.
func (m *MockCmdable) HLen(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HLen", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// HMGet mocks base method.
func (m *MockCmdable) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HMGet", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// HMGet indicates an expected call of HMGet.
func (mr *MockCmdableMockRecorder) HMGet(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockCmdable)(nil).HMGet), varargs...)
}

// HMSet mocks base method.
func (m *MockCmdable) HMSet(ctx context.Context, key string, values ...any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HMSet", varargs...)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// HMSet indicates an expected call of HMSet.
func (mr *MockCmdableMockRecorder) HMSet(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockCmdable)(nil).HMSet), varargs...)
}

// HPExpire mocks base method.
func (m *MockCmdable) HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpire", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpire indicates an expected call of HPExpire.
func (mr *MockCmdableMockRecorder) HPExpire(ctx, key, expiration any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpire", reflect.TypeOf((*MockCmdable)(nil).HPExpire), varargs...)
}

// HPExpireAt mocks base method.
func (m *MockCmdable) HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireAt", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireAt indicates an expected call of HPExpireAt.
func (mr *MockCmdableMockRecorder) HPExpireAt(ctx, key, tm any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAt", reflect.TypeOf((*MockCmdable)(nil).HPExpireAt), varargs...)
}

// HPExpireAtWithArgs mocks base method.
func (m *MockCmdable) HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireAtWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireAtWithArgs indicates an expected call of HPExpireAtWithArgs.
func (mr *MockCmdableMockRecorder) HPExpireAtWithArgs(ctx, key, tm, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAtWithArgs", reflect.TypeOf((*MockCmdable)(nil).HPExpireAtWithArgs), varargs...)
}

// HPExpireTime mocks base method.
func (m *MockCmdable) HPExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireTime", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireTime indicates an expected call of HPExpireTime.
func (mr *MockCmdableMockRecorder) HPExpireTime(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireTime", reflect.TypeOf((*MockCmdable)(nil).HPExpireTime), varargs...)
}

// HPExpireWithArgs mocks base method.
func (m *MockCmdable) HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireWithArgs indicates an expected call of HPExpireWithArgs.
func (mr *MockCmdableMockRecorder) HPExpireWithArgs(ctx, key, expiration, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireWithArgs", reflect.TypeOf((*MockCmdable)(nil).HPExpireWithArgs), varargs...)
}

// HPTTL mocks base method.
func (m *MockCmdable) HPTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPTTL", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPTTL indicates an expected call of HPTTL.
func (mr *MockCmdableMockRecorder) HPTTL(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPTTL", reflect.TypeOf((*MockCmdable)(nil).HPTTL), varargs...)
}

// HPersist mocks base method.
func (m *MockCmdable) HPersist(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPersist", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPersist indicates an expected call of HPersist.
func (mr *MockCmdableMockRecorder) HPersist(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPersist", reflect.TypeOf((*MockCmdable)(nil).HPersist), varargs...)
}

// HRandField mocks base method.
func (m *MockCmdable) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HRandField", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HRandField indicates an expected call of HRandField.
func (mr *MockCmdableMockRecorder) HRandField(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockCmdable)(nil).HRandField), ctx, key, count)
}

// HRandFieldWithValues mocks base method.
func (m *MockCmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count)
	ret0, _ := ret[0].(*redis.KeyValueSliceCmd)
	return ret0
}

// HRandFieldWithValues indicates an expected call of HRandFieldWithValues.
func (mr *MockCmdableMockRecorder) HRandFieldWithValues(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockCmdable)(nil).HRandFieldWithValues), ctx, key, count)
}

// HScan mocks base method.
func (m *MockCmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// HScan indicates an expected call of HScan.
func (mr *MockCmdableMockRecorder) HScan(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockCmdable)(nil).HScan), ctx, key, cursor, match, count)
}

// HScanNoValues mocks base method.
func (m *MockCmdable) HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HScanNoValues", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// HScanNoValues indicates an expected call of HScanNoValues.
func (mr *MockCmdableMockRecorder) HScanNoValues(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScanNoValues", reflect.TypeOf((*MockCmdable)(nil).HScanNoValues), ctx, key, cursor, match, count)
}

// HSet mocks base method.
func (m *MockCmdable) HSet(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HSet", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HSet indicates an expected call of HSet.
func (mr *MockCmdableMockRecorder) HSet(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockCmdable)(nil).HSet), varargs...)
}

// HSetEX mocks base method.
func (m *MockCmdable) HSetEX(ctx context.Context, key string, fieldsAndValues ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fieldsAndValues {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HSetEX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HSetEX indicates an expected call of HSetEX.
func (mr *MockCmdableMockRecorder) HSetEX(ctx, key any, fieldsAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fieldsAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetEX", reflect.TypeOf((*MockCmdable)(nil).HSetEX), varargs...)
}

// HSetEXWithArgs mocks base method.
func (m *MockCmdable) HSetEXWithArgs(ctx context.Context, key string, options *redis.HSetEXOptions, fieldsAndValues ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range fieldsAndValues {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HSetEXWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HSetEXWithArgs indicates an expected call of HSetEXWithArgs.
func (mr *MockCmdableMockRecorder) HSetEXWithArgs(ctx, key, options any, fieldsAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, fieldsAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetEXWithArgs", reflect.TypeOf((*MockCmdable)(nil).HSetEXWithArgs), varargs...)
}

// HSetNX mocks base method.
func (m *MockCmdable) HSetNX(ctx context.Context, key, field string, value any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// HSetNX indicates an expected call of HSetNX.
func (mr *MockCmdableMockRecorder) HSetNX(ctx, key, field, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockCmdable)(nil).HSetNX), ctx, key, field, value)
}

// HStrLen mocks base method.
func (m *MockCmdable) HStrLen(ctx context.Context, key, field string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HStrLen", ctx, key, field)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HStrLen indicates an expected call of HStrLen.
func (mr *MockCmdableMockRecorder) HStrLen(ctx, key, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HStrLen", reflect.TypeOf((*MockCmdable)(nil).HStrLen), ctx, key, field)
}

// HTTL mocks base method.
func (m *MockCmdable) HTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HTTL", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HTTL indicates an expected call of HTTL.
func (mr *MockCmdableMockRecorder) HTTL(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTL", reflect.TypeOf((*MockCmdable)(nil).HTTL), varargs...)
}

// HVals mocks base method.
func (m *MockCmdable) HVals(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HVals", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// Incr mocks base method.
func (m *MockCmdable) Incr(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Incr", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// IncrBy mocks base method.
func (m *MockCmdable) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrBy", ctx, key, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// IncrBy indicates an expected call of IncrBy.
func (mr *MockCmdableMockRecorder) IncrBy(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockCmdable)(nil).IncrBy), ctx, key, value)
}

// IncrByFloat mocks base method.
func (m *MockCmdable) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// IncrByFloat indicates an expected call of IncrByFloat.
func (mr *MockCmdableMockRecorder) IncrByFloat(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockCmdable)(nil).IncrByFloat), ctx, key, value)
}

// Info mocks base method.
func (m *MockCmdable) Info(ctx context.Context, section ...string) *redis.StringCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range section {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Info", varargs...)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockCmdableMockRecorder) Info(ctx any, section ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, section...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockCmdable)(nil).Info), varargs...)
}

// JSONArrAppend mocks base method.
func (m *MockCmdable) JSONArrAppend(ctx context.Context, key, path string, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrAppend", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrAppend indicates an expected call of JSONArrAppend.
func (mr *MockCmdableMockRecorder) JSONArrAppend(ctx, key, path any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrAppend", reflect.TypeOf((*MockCmdable)(nil).JSONArrAppend), varargs...)
}

// JSONArrIndex mocks base method.
func (m *MockCmdable) JSONArrIndex(ctx context.Context, key, path string, value ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path}
	for _, a := range value {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrIndex", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrIndex indicates an expected call of JSONArrIndex.
func (mr *MockCmdableMockRecorder) JSONArrIndex(ctx, key, path any, value ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path}, value...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndex", reflect.TypeOf((*MockCmdable)(nil).JSONArrIndex), varargs...)
}

// JSONArrIndexWithArgs mocks base method.
func (m *MockCmdable) JSONArrIndexWithArgs(ctx context.Context, key, path string, options *redis.JSONArrIndexArgs, value ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path, options}
	for _, a := range value {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrIndexWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrIndexWithArgs indicates an expected call of JSONArrIndexWithArgs.
func (mr *MockCmdableMockRecorder) JSONArrIndexWithArgs(ctx, key, path, options any, value ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path, options}, value...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndexWithArgs", reflect.TypeOf((*MockCmdable)(nil).JSONArrIndexWithArgs), varargs...)
}

// JSONArrInsert mocks base method.
func (m *MockCmdable) JSONArrInsert(ctx context.Context, key, path string, index int64, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path, index}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrInsert", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrInsert indicates an expected call of JSONArrInsert.
func (mr *MockCmdableMockRecorder) JSONArrInsert(ctx, key, path, index any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path, index}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrInsert", reflect.TypeOf((*MockCmdable)(nil).JSONArrInsert), varargs...)
}

// JSONArrLen mocks base method.
func (m *MockCmdable) JSONArrLen(ctx context.Context, key, path string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrLen", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrLen indicates an expected call of JSONArrLen.
func (mr *MockCmdableMockRecorder) JSONArrLen(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrLen", reflect.TypeOf((*MockCmdable)(nil).JSONArrLen), ctx, key, path)
}

// JSONArrPop mocks base method.
func (m *MockCmdable) JSONArrPop(ctx context.Context, key, path string, index int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrPop", ctx, key, path, index)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// JSONArrPop indicates an expected call of JSONArrPop.
func (mr *MockCmdableMockRecorder) JSONArrPop(ctx, key, path, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrPop", reflect.TypeOf((*MockCmdable)(nil).JSONArrPop), ctx, key, path, index)
}

// JSONArrTrim mocks base method.
func (m *MockCmdable) JSONArrTrim(ctx context.Context, key, path string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrTrim", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrTrim indicates an expected call of JSONArrTrim.
func (mr *MockCmdableMockRecorder) JSONArrTrim(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrim", reflect.TypeOf((*MockCmdable)(nil).JSONArrTrim), ctx, key, path)
}

// JSONArrTrimWithArgs mocks base method.
func (m *MockCmdable) JSONArrTrimWithArgs(ctx context.Context, key, path string, options *redis.JSONArrTrimArgs) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrTrimWithArgs", ctx, key, path, options)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrTrimWithArgs indicates an expected call of JSONArrTrimWithArgs.
func (mr *MockCmdableMockRecorder) JSONArrTrimWithArgs(ctx, key, path, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrimWithArgs", reflect.TypeOf((*MockCmdable)(nil).JSONArrTrimWithArgs), ctx, key, path, options)
}

// JSONClear mocks base method.
func (m *MockCmdable) JSONClear(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONClear", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONClear indicates an expected call of JSONClear.
func (mr *MockCmdableMockRecorder) JSONClear(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONClear", reflect.TypeOf((*MockCmdable)(nil).JSONClear), ctx, key, path)
}

// JSONDebugMemory mocks base method.
func (m *MockCmdable) JSONDebugMemory(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONDebugMemory", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONDebugMemory indicates an expected call of JSONDebugMemory.
func (mr *MockCmdableMockRecorder) JSONDebugMemory(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDebugMemory", reflect.TypeOf((*MockCmdable)(nil).JSONDebugMemory), ctx, key, path)
}

// JSONDel mocks base method.
func (m *MockCmdable) JSONDel(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONDel", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONDel indicates an expected call of JSONDel.
func (mr *MockCmdableMockRecorder) JSONDel(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDel", reflect.TypeOf((*MockCmdable)(nil).JSONDel), ctx, key, path)
}

// JSONForget mocks base method.
func (m *MockCmdable) JSONForget(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONForget", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONForget indicates an expected call of JSONForget.
func (mr *MockCmdableMockRecorder) JSONForget(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONForget", reflect.TypeOf((*MockCmdable)(nil).JSONForget), ctx, key, path)
}

// JSONGet mocks base method.
func (m *MockCmdable) JSONGet(ctx context.Context, key string, paths ...string) *redis.JSONCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range paths {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONGet", varargs...)
	ret0, _ := ret[0].(*redis.JSONCmd)
	return ret0
}

// JSONGet indicates an expected call of JSONGet.
func (mr *MockCmdableMockRecorder) JSONGet(ctx, key any, paths ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, paths...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGet", reflect.TypeOf((*MockCmdable)(nil).JSONGet), varargs...)
}

// JSONGetWithArgs mocks base method.
func (m *MockCmdable) JSONGetWithArgs(ctx context.Context, key string, options *redis.JSONGetArgs, paths ...string) *redis.JSONCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range paths {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONGetWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.JSONCmd)
	return ret0
}

// JSONGetWithArgs indicates an expected call of JSONGetWithArgs.
func (mr *MockCmdableMockRecorder) JSONGetWithArgs(ctx, key, options any, paths ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, paths...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).JSONGetWithArgs), varargs...)
}

// JSONMGet mocks base method.
func (m *MockCmdable) JSONMGet(ctx context.Context, path string, keys ...string) *redis.JSONSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, path}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONMGet", varargs...)
	ret0, _ := ret[0].(*redis.JSONSliceCmd)
	return ret0
}

// JSONMGet indicates an expected call of JSONMGet.
func (mr *MockCmdableMockRecorder) JSONMGet(ctx, path any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, path}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMGet", reflect.TypeOf((*MockCmdable)(nil).JSONMGet), varargs...)
}

// JSONMSet mocks base method.
func (m *MockCmdable) JSONMSet(ctx context.Context, params ...any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONMSet", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONMSet indicates an expected call of JSONMSet.
func (mr *MockCmdableMockRecorder) JSONMSet(ctx any, params ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, params...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSet", reflect.TypeOf((*MockCmdable)(nil).JSONMSet), varargs...)
}

// JSONMSetArgs mocks base method.
func (m *MockCmdable) JSONMSetArgs(ctx context.Context, docs []redis.JSONSetArgs) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONMSetArgs", ctx, docs)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONMSetArgs indicates an expected call of JSONMSetArgs.
func (mr *MockCmdableMockRecorder) JSONMSetArgs(ctx, docs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSetArgs", reflect.TypeOf((*MockCmdable)(nil).JSONMSetArgs), ctx, docs)
}

// JSONMerge mocks base method.
func (m *MockCmdable) JSONMerge(ctx context.Context, key, path, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONMerge", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONMerge indicates an expected call of JSONMerge.
func (mr *MockCmdableMockRecorder) JSONMerge(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMerge", reflect.TypeOf((*MockCmdable)(nil).JSONMerge), ctx, key, path, value)
}

// JSONNumIncrBy mocks base method.
func (m *MockCmdable) JSONNumIncrBy(ctx context.Context, key, path string, value float64) *redis.JSONCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONNumIncrBy", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.JSONCmd)
	return ret0
}

// JSONNumIncrBy indicates an expected call of JSONNumIncrBy.
func (mr *MockCmdableMockRecorder) JSONNumIncrBy(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONNumIncrBy", reflect.TypeOf((*MockCmdable)(nil).JSONNumIncrBy), ctx, key, path, value)
}

// JSONObjKeys mocks base method.
func (m *MockCmdable) JSONObjKeys(ctx context.Context, key, path string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONObjKeys", ctx, key, path)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// JSONObjKeys indicates an expected call of JSONObjKeys.
func (mr *MockCmdableMockRecorder) JSONObjKeys(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjKeys", reflect.TypeOf((*MockCmdable)(nil).JSONObjKeys), ctx, key, path)
}

// JSONObjLen mocks base method.
func (m *MockCmdable) JSONObjLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONObjLen", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONObjLen indicates an expected call of JSONObjLen.
func (mr *MockCmdableMockRecorder) JSONObjLen(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjLen", reflect.TypeOf((*MockCmdable)(nil).JSONObjLen), ctx, key, path)
}

// JSONSet mocks base method.
func (m *MockCmdable) JSONSet(ctx context.Context, key, path string, value any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONSet", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONSet indicates an expected call of JSONSet.
func (mr *MockCmdableMockRecorder) JSONSet(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSet", reflect.TypeOf((*MockCmdable)(nil).JSONSet), ctx, key, path, value)
}

// JSONSetMode mocks base method.
func (m *MockCmdable) JSONSetMode(ctx context.Context, key, path string, value any, mode string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONSetMode", ctx, key, path, value, mode)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONSetMode indicates an expected call of JSONSetMode.
func (mr *MockCmdableMockRecorder) JSONSetMode(ctx, key, path, value, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSetMode", reflect.TypeOf((*MockCmdable)(nil).JSONSetMode), ctx, key, path, value, mode)
}

// JSONStrAppend mocks base method.
func (m *MockCmdable) JSONStrAppend(ctx context.Context, key, path, value string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONStrAppend", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONStrAppend indicates an expected call of JSONStrAppend.
func (mr *MockCmdableMockRecorder) JSONStrAppend(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrAppend", reflect.TypeOf((*MockCmdable)(nil).JSONStrAppend), ctx, key, path, value)
}

// JSONStrLen mocks base method.
func (m *MockCmdable) JSONStrLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONStrLen", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONStrLen indicates an expected call of JSONStrLen.
func (mr *MockCmdableMockRecorder) JSONStrLen(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrLen", reflect.TypeOf((*MockCmdable)(nil).JSONStrLen), ctx, key, path)
}

// JSONToggle mocks base method.
func (m *MockCmdable) JSONToggle(ctx context.Context, key, path string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONToggle", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONToggle indicates an expected call of JSONToggle.
func (mr *MockCmdableMockRecorder) JSONToggle(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONToggle", reflect.TypeOf((*MockCmdable)(nil).JSONToggle), ctx, key, path)
}

// JSONType mocks base method.
func (m *MockCmdable) JSONType(ctx context.Context, key, path string) *redis.JSONSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONType", ctx, key, path)
	ret0, _ := ret[0].(*redis.JSONSliceCmd)
	return ret0
}

// JSONType indicates an expected call of JSONType.
func (mr *MockCmdableMockRecorder) JSONType(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONType", reflect.TypeOf((*MockCmdable)(nil).JSONType), ctx, key, path)
}

// Keys mocks base method.
func (m *MockCmdable) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Keys", ctx, pattern)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// LCS mocks base method.
func (m *MockCmdable) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LCS", ctx, q)
	ret0, _ := ret[0].(*redis.LCSCmd)
	return ret0
}

// LCS indicates an expected call of LCS.
func (mr *MockCmdableMockRecorder) LCS(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockCmdable)(nil).LCS), ctx, q)
}

// LIndex mocks base method.
func (m *MockCmdable) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LIndex", ctx, key, index)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// LIndex indicates an expected call of LIndex.
func (mr *MockCmdableMockRecorder) LIndex(ctx, key, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCmdable)(nil).LIndex), ctx, key, index)
}

// LInsert mocks base method.
func (m *MockCmdable) LInsert(ctx context.Context, key, op string, pivot, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LInsert indicates an expected call of LInsert.
func (mr *MockCmdableMockRecorder) LInsert(ctx, key, op, pivot, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockCmdable)(nil).LInsert), ctx, key, op, pivot, value)
}

// LInsertAfter mocks base method.
func (m *MockCmdable) LInsertAfter(ctx context.Context, key string, pivot, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LInsertAfter indicates an expected call of LInsertAfter.
func (mr *MockCmdableMockRecorder) LInsertAfter(ctx, key, pivot, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockCmdable)(nil).LInsertAfter), ctx, key, pivot, value)
}

// LInsertBefore mocks base method.
func (m *MockCmdable) LInsertBefore(ctx context.Context, key string, pivot, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LInsertBefore indicates an expected call of LInsertBefore.
func (mr *MockCmdableMockRecorder) LInsertBefore(ctx, key, pivot, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockCmdable)(nil).LInsertBefore), ctx, key, pivot, value)
}

// LLen mocks base method.
func (m *MockCmdable) LLen(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LLen", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// LMPop mocks base method.
func (m *MockCmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, direction, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LMPop", varargs...)
	ret0, _ := ret[0].(*redis.KeyValuesCmd)
	return ret0
}

// LMPop indicates an expected call of LMPop.
func (mr *MockCmdableMockRecorder) LMPop(ctx, direction, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, direction, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockCmdable)(nil).LMPop), varargs...)
}

// LMove mocks base method.
func (m *MockCmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// LMove indicates an expected call of LMove.
func (mr *MockCmdableMockRecorder) LMove(ctx, source, destination, srcpos, destpos any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockCmdable)(nil).LMove), ctx, source, destination, srcpos, destpos)
}

// LPop mocks base method.
func (m *MockCmdable) LPop(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPop", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// LPopCount mocks base method.
func (m *MockCmdable) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPopCount", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// LPopCount indicates an expected call of LPopCount.
func (mr *MockCmdableMockRecorder) LPopCount(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockCmdable)(nil).LPopCount), ctx, key, count)
}

// LPos mocks base method.
func (m *MockCmdable) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPos", ctx, key, value, args)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LPos indicates an expected call of LPos.
func (mr *MockCmdableMockRecorder) LPos(ctx, key, value, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockCmdable)(nil).LPos), ctx, key, value, args)
}

// LPosCount mocks base method.
func (m *MockCmdable) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// LPosCount indicates an expected call of LPosCount.
func (mr *MockCmdableMockRecorder) LPosCount(ctx, key, value, count, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockCmdable)(nil).LPosCount), ctx, key, value, count, args)
}

// LPush mocks base method.
func (m *MockCmdable) LPush(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LPush", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LPush indicates an expected call of LPush.
func (mr *MockCmdableMockRecorder) LPush(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockCmdable)(nil).LPush), varargs...)
}

// LPushX mocks base method.
func (m *MockCmdable) LPushX(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LPushX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LPushX indicates an expected call of LPushX.
func (mr *MockCmdableMockRecorder) LPushX(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockCmdable)(nil).LPushX), varargs...)
}

// LRange mocks base method.
func (m *MockCmdable) LRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// LRange indicates an expected call of LRange.
func (mr *MockCmdableMockRecorder) LRange(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCmdable)(nil).LRange), ctx, key, start, stop)
}

// LRem mocks base method.
func (m *MockCmdable) LRem(ctx context.Context, key string, count int64, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRem", ctx, key, count, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LRem indicates an expected call of LRem.
func (mr *MockCmdableMockRecorder) LRem(ctx, key, count, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCmdable)(nil).LRem), ctx, key, count, value)
}

// LSet mocks base method.
func (m *MockCmdable) LSet(ctx context.Context, key string, index int64, value any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LSet", ctx, key, index, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// LSet indicates an expected call of LSet.
func (mr *MockCmdableMockRecorder) LSet(ctx, key, index, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCmdable)(nil).LSet), ctx, key, index, value)
}

// LTrim mocks base method.
func (m *MockCmdable) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// LTrim indicates an expected call of LTrim.
func (mr *MockCmdableMockRecorder) LTrim(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCmdable)(nil).LTrim), ctx, key, start, stop)
}

// LastSave mocks base method.
func (m *MockCmdable) LastSave(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastSave", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LastSave indicates an expected call of LastSave.
func (mr *MockCmdableMockRecorder) LastSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockCmdable)(nil).LastSave), ctx)
}

// MGet mocks base method.
func (m *MockCmdable) MGet(ctx context.Context, keys ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MGet", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// MGet indicates an expected call of MGet.
func (mr *MockCmdableMockRecorder) MGet(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockCmdable)(nil).MGet), varargs...)
}

// MSet mocks base method.
func (m *MockCmdable) MSet(ctx context.Context, values ...any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MSet", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// MSet indicates an expected call of MSet.
func (mr *MockCmdableMockRecorder) MSet(ctx any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockCmdable)(nil).MSet), varargs...)
}

// MSetNX mocks base method.
func (m *MockCmdable) MSetNX(ctx context.Context, values ...any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MSetNX", varargs...)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// MSetNX indicates an expected call of MSetNX.
func (mr *MockCmdableMockRecorder) MSetNX(ctx any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockCmdable)(nil).MSetNX), varargs...)
}

// MemoryUsage mocks base method.
func (m *MockCmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range samples {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MemoryUsage", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// MemoryUsage indicates an expected call of MemoryUsage.
func (mr *MockCmdableMockRecorder) MemoryUsage(ctx, key any, samples ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, samples...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockCmdable)(nil).MemoryUsage), varargs...)
}

// Migrate mocks base method.
func (m *MockCmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Migrate indicates an expected call of Migrate.
func (mr *MockCmdableMockRecorder) Migrate(ctx, host, port, key, db, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockCmdable)(nil).Migrate), ctx, host, port, key, db, timeout)
}

// ModuleLoadex mocks base method.
func (m *MockCmdable) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ModuleLoadex indicates an expected call of ModuleLoadex.
func (mr *MockCmdableMockRecorder) ModuleLoadex(ctx, conf any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockCmdable)(nil).ModuleLoadex), ctx, conf)
}

// Move mocks base method.
func (m *MockCmdable) Move(ctx context.Context, key string, db int) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Move", ctx, key, db)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// Move indicates an expected call of Move.
func (mr *MockCmdableMockRecorder) Move(ctx, key, db any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockCmdable)(nil).Move), ctx, key, db)
}

// ObjectEncoding mocks base method.
func (m *MockCmdable) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// ObjectFreq mocks base method.
func (m *MockCmdable) ObjectFreq(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectFreq", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// ObjectIdleTime mocks base method.
func (m *MockCmdable) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// ObjectRefCount mocks base method.
func (m *MockCmdable) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// PExpire mocks base method.
func (m *MockCmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// PExpireAt mocks base method.
func (m *MockCmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// PExpireAt indicates an expected call of PExpireAt.
func (mr *MockCmdableMockRecorder) PExpireAt(ctx, key, tm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockCmdable)(nil).PExpireAt), ctx, key, tm)
}

// PExpireTime mocks base method.
func (m *MockCmdable) PExpireTime(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PExpireTime", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// PFAdd mocks base method.
func (m *MockCmdable) PFAdd(ctx context.Context, key string, els ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range els {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// PFCount mocks base method.
func (m *MockCmdable) PFCount(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFCount", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// PFCount indicates an expected call of PFCount.
func (mr *MockCmdableMockRecorder) PFCount(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockCmdable)(nil).PFCount), varargs...)
}

// PFMerge mocks base method.
func (m *MockCmdable) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dest}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFMerge", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// PTTL mocks base method.
func (m *MockCmdable) PTTL(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PTTL", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// Persist mocks base method.
func (m *MockCmdable) Persist(ctx context.Context, key string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Persist", ctx, key)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// Ping mocks base method.
func (m *MockCmdable) Ping(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ping", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Ping indicates an expected call of Ping.
func (mr *MockCmdableMockRecorder) Ping(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCmdable)(nil).Ping), ctx)
}

// Pipeline mocks base method.
func (m *MockCmdable) Pipeline() redis.Pipeliner {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipeline")
	ret0, _ := ret[0].(redis.Pipeliner)
	return ret0
}

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

// Pipelined mocks base method.
func (m *MockCmdable) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipelined", ctx, fn)
	ret0, _ := ret[0].([]redis.Cmder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pipelined indicates an expected call of Pipelined.
func (mr *MockCmdableMockRecorder) Pipelined(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockCmdable)(nil).Pipelined), ctx, fn)
}

// PubSubChannels mocks base method.
func (m *MockCmdable) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// PubSubChannels indicates an expected call of PubSubChannels.
func (mr *MockCmdableMockRecorder) PubSubChannels(ctx, pattern any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubChannels), ctx, pattern)
}

// PubSubNumPat mocks base method.
func (m *MockCmdable) PubSubNumPat(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PubSubNumPat", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// PubSubNumPat indicates an expected call of PubSubNumPat.
func (mr *MockCmdableMockRecorder) PubSubNumPat(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockCmdable)(nil).PubSubNumPat), ctx)
}

// PubSubNumSub mocks base method.
func (m *MockCmdable) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PubSubNumSub", varargs...)
	ret0, _ := ret[0].(*redis.MapStringIntCmd)
	return ret0
}

// PubSubNumSub indicates an expected call of PubSubNumSub.
func (mr *MockCmdableMockRecorder) PubSubNumSub(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubNumSub), varargs...)
}

// PubSubShardChannels mocks base method.
func (m *MockCmdable) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// PubSubShardChannels indicates an expected call of PubSubShardChannels.
func (mr *MockCmdableMockRecorder) PubSubShardChannels(ctx, pattern any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubShardChannels), ctx, pattern)
}

// PubSubShardNumSub mocks base method.
func (m *MockCmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...)
	ret0, _ := ret[0].(*redis.MapStringIntCmd)
	return ret0
}

// PubSubShardNumSub indicates an expected call of PubSubShardNumSub.
func (mr *MockCmdableMockRecorder) PubSubShardNumSub(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubShardNumSub), varargs...)
}

// Publish mocks base method.
func (m *MockCmdable) Publish(ctx context.Context, channel string, message any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Publish", ctx, channel, message)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Publish indicates an expected call of Publish.
func (mr *MockCmdableMockRecorder) Publish(ctx, channel, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockCmdable)(nil).Publish), ctx, channel, message)
}

// Quit mocks base method.
func (m *MockCmdable) Quit(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Quit", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Quit indicates an expected call of Quit.
func (mr *MockCmdableMockRecorder) Quit(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockCmdable)(nil).Quit), ctx)
}

// RPop mocks base method.
func (m *MockCmdable) RPop(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPop", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// RPopCount mocks base method.
func (m *MockCmdable) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPopCount", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// RPopCount indicates an expected call of RPopCount.
func (mr *MockCmdableMockRecorder) RPopCount(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockCmdable)(nil).RPopCount), ctx, key, count)
}

// RPopLPush mocks base method.
func (m *MockCmdable) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// RPopLPush indicates an expected call of RPopLPush.
func (mr *MockCmdableMockRecorder) RPopLPush(ctx, source, destination any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockCmdable)(nil).RPopLPush), ctx, source, destination)
}

// RPush mocks base method.
func (m *MockCmdable) RPush(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RPush", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// RPush indicates an expected call of RPush.
func (mr *MockCmdableMockRecorder) RPush(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockCmdable)(nil).RPush), varargs...)
}

// RPushX mocks base method.
func (m *MockCmdable) RPushX(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RPushX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// RPushX indicates an expected call of RPushX.
func (mr *MockCmdableMockRecorder) RPushX(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockCmdable)(nil).RPushX), varargs...)
}

// RandomKey mocks base method.
func (m *MockCmdable) RandomKey(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RandomKey", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// RandomKey indicates an expected call of RandomKey.
func (mr *MockCmdableMockRecorder) RandomKey(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockCmdable)(nil).RandomKey), ctx)
}

// ReadOnly mocks base method.
func (m *MockCmdable) ReadOnly(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadOnly", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ReadOnly indicates an expected call of ReadOnly.
func (mr *MockCmdableMockRecorder) ReadOnly(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockCmdable)(nil).ReadOnly), ctx)
}

// ReadWrite mocks base method.
func (m *MockCmdable) ReadWrite(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadWrite", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ReadWrite indicates an expected call of ReadWrite.
func (mr *MockCmdableMockRecorder) ReadWrite(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockCmdable)(nil).ReadWrite), ctx)
}

// Rename mocks base method.
func (m *MockCmdable) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rename", ctx, key, newkey)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Rename indicates an expected call of Rename.
func (mr *MockCmdableMockRecorder) Rename(ctx, key, newkey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockCmdable)(nil).Rename), ctx, key, newkey)
}

// RenameNX mocks base method.
func (m *MockCmdable) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// RenameNX indicates an expected call of RenameNX.
func (mr *MockCmdableMockRecorder) RenameNX(ctx, key, newkey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockCmdable)(nil).RenameNX), ctx, key, newkey)
}

// Restore mocks base method.
func (m *MockCmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Restore indicates an expected call of Restore.
func (mr *MockCmdableMockRecorder) Restore(ctx, key, ttl, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockCmdable)(nil).Restore), ctx, key, ttl, value)
}

// RestoreReplace mocks base method.
func (m *MockCmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// RestoreReplace indicates an expected call of RestoreReplace.
func (mr *MockCmdableMockRecorder) RestoreReplace(ctx, key, ttl, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockCmdable)(nil).RestoreReplace), ctx, key, ttl, value)
}

// SAdd mocks base method.
func (m *MockCmdable) SAdd(ctx context.Context, key string, members ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SAdd indicates an expected call of SAdd.
func (mr *MockCmdableMockRecorder) SAdd(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockCmdable)(nil).SAdd), varargs...)
}

// SCard mocks base method.
func (m *MockCmdable) SCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// SDiff mocks base method.
func (m *MockCmdable) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SDiff", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SDiff indicates an expected call of SDiff.
func (mr *MockCmdableMockRecorder) SDiff(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockCmdable)(nil).SDiff), varargs...)
}

// SDiffStore mocks base method.
func (m *MockCmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SDiffStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SDiffStore indicates an expected call of SDiffStore.
func (mr *MockCmdableMockRecorder) SDiffStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockCmdable)(nil).SDiffStore), varargs...)
}

// SInter mocks base method.
func (m *MockCmdable) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SInter", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SInter indicates an expected call of SInter.
func (mr *MockCmdableMockRecorder) SInter(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockCmdable)(nil).SInter), varargs...)
}

// SInterCard mocks base method.
func (m *MockCmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, limit}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SInterCard", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SInterCard indicates an expected call of SInterCard.
func (mr *MockCmdableMockRecorder) SInterCard(ctx, limit any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, limit}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockCmdable)(nil).SInterCard), varargs...)
}

// SInterStore mocks base method.
func (m *MockCmdable) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SInterStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SInterStore indicates an expected call of SInterStore.
func (mr *MockCmdableMockRecorder) SInterStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockCmdable)(nil).SInterStore), varargs...)
}

// SIsMember mocks base method.
func (m *MockCmdable) SIsMember(ctx context.Context, key string, member any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SIsMember", ctx, key, member)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// SIsMember indicates an expected call of SIsMember.
func (mr *MockCmdableMockRecorder) SIsMember(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCmdable)(nil).SIsMember), ctx, key, member)
}

// SMIsMember mocks base method.
func (m *MockCmdable) SMIsMember(ctx context.Context, key string, members ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SMIsMember", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// SMIsMember indicates an expected call of SMIsMember.
func (mr *MockCmdableMockRecorder) SMIsMember(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockCmdable)(nil).SMIsMember), varargs...)
}

// SMembers mocks base method.
func (m *MockCmdable) SMembers(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembers", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// SMembersMap mocks base method.
func (m *MockCmdable) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembersMap", ctx, key)
	ret0, _ := ret[0].(*redis.StringStructMapCmd)
	return ret0
}

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

// SMove mocks base method.
func (m *MockCmdable) SMove(ctx context.Context, source, destination string, member any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// SMove indicates an expected call of SMove.
func (mr *MockCmdableMockRecorder) SMove(ctx, source, destination, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCmdable)(nil).SMove), ctx, source, destination, member)
}

// SPop mocks base method.
func (m *MockCmdable) SPop(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPop", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// SPopN mocks base method.
func (m *MockCmdable) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPopN", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SPopN indicates an expected call of SPopN.
func (mr *MockCmdableMockRecorder) SPopN(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockCmdable)(nil).SPopN), ctx, key, count)
}

// SPublish mocks base method.
func (m *MockCmdable) SPublish(ctx context.Context, channel string, message any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPublish", ctx, channel, message)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SPublish indicates an expected call of SPublish.
func (mr *MockCmdableMockRecorder) SPublish(ctx, channel, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockCmdable)(nil).SPublish), ctx, channel, message)
}

// SRandMember mocks base method.
func (m *MockCmdable) SRandMember(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SRandMember", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// SRandMemberN mocks base method.
func (m *MockCmdable) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SRandMemberN indicates an expected call of SRandMemberN.
func (mr *MockCmdableMockRecorder) SRandMemberN(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockCmdable)(nil).SRandMemberN), ctx, key, count)
}

// SRem mocks base method.
func (m *MockCmdable) SRem(ctx context.Context, key string, members ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SRem", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SRem indicates an expected call of SRem.
func (mr *MockCmdableMockRecorder) SRem(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockCmdable)(nil).SRem), varargs...)
}

// SScan mocks base method.
func (m *MockCmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// SScan indicates an expected call of SScan.
func (mr *MockCmdableMockRecorder) SScan(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCmdable)(nil).SScan), ctx, key, cursor, match, count)
}

// SUnion mocks base method.
func (m *MockCmdable) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SUnion", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SUnion indicates an expected call of SUnion.
func (mr *MockCmdableMockRecorder) SUnion(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockCmdable)(nil).SUnion), varargs...)
}

// SUnionStore mocks base method.
func (m *MockCmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SUnionStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SUnionStore indicates an expected call of SUnionStore.
func (mr *MockCmdableMockRecorder) SUnionStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockCmdable)(nil).SUnionStore), varargs...)
}

// Save mocks base method.
func (m *MockCmdable) Save(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Save indicates an expected call of Save.
func (mr *MockCmdableMockRecorder) Save(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCmdable)(nil).Save), ctx)
}

// Scan mocks base method.
func (m *MockCmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

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

// ScanType mocks base method.
func (m *MockCmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// ScanType indicates an expected call of ScanType.
func (mr *MockCmdableMockRecorder) ScanType(ctx, cursor, match, count, keyType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockCmdable)(nil).ScanType), ctx, cursor, match, count, keyType)
}

// ScriptExists mocks base method.
func (m *MockCmdable) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range hashes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScriptExists", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// ScriptExists indicates an expected call of ScriptExists.
func (mr *MockCmdableMockRecorder) ScriptExists(ctx any, hashes ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, hashes...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockCmdable)(nil).ScriptExists), varargs...)
}

// ScriptFlush mocks base method.
func (m *MockCmdable) ScriptFlush(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScriptFlush", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ScriptFlush indicates an expected call of ScriptFlush.
func (mr *MockCmdableMockRecorder) ScriptFlush(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockCmdable)(nil).ScriptFlush), ctx)
}

// ScriptKill mocks base method.
func (m *MockCmdable) ScriptKill(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScriptKill", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ScriptKill indicates an expected call of ScriptKill.
func (mr *MockCmdableMockRecorder) ScriptKill(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockCmdable)(nil).ScriptKill), ctx)
}

// ScriptLoad mocks base method.
func (m *MockCmdable) ScriptLoad(ctx context.Context, script string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScriptLoad", ctx, script)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ScriptLoad indicates an expected call of ScriptLoad.
func (mr *MockCmdableMockRecorder) ScriptLoad(ctx, script any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockCmdable)(nil).ScriptLoad), ctx, script)
}

// Set mocks base method.
func (m *MockCmdable) Set(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// SetArgs mocks base method.
func (m *MockCmdable) SetArgs(ctx context.Context, key string, value any, a redis.SetArgs) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// SetArgs indicates an expected call of SetArgs.
func (mr *MockCmdableMockRecorder) SetArgs(ctx, key, value, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockCmdable)(nil).SetArgs), ctx, key, value, a)
}

// SetBit mocks base method.
func (m *MockCmdable) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBit", ctx, key, offset, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SetBit indicates an expected call of SetBit.
func (mr *MockCmdableMockRecorder) SetBit(ctx, key, offset, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockCmdable)(nil).SetBit), ctx, key, offset, value)
}

// SetEx mocks base method.
func (m *MockCmdable) SetEx(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// SetNX mocks base method.
func (m *MockCmdable) SetNX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// SetRange mocks base method.
func (m *MockCmdable) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SetRange indicates an expected call of SetRange.
func (mr *MockCmdableMockRecorder) SetRange(ctx, key, offset, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockCmdable)(nil).SetRange), ctx, key, offset, value)
}

// SetXX mocks base method.
func (m *MockCmdable) SetXX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// Shutdown mocks base method.
func (m *MockCmdable) Shutdown(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Shutdown", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Shutdown indicates an expected call of Shutdown.
func (mr *MockCmdableMockRecorder) Shutdown(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockCmdable)(nil).Shutdown), ctx)
}

// ShutdownNoSave mocks base method.
func (m *MockCmdable) ShutdownNoSave(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShutdownNoSave", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ShutdownNoSave indicates an expected call of ShutdownNoSave.
func (mr *MockCmdableMockRecorder) ShutdownNoSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownNoSave), ctx)
}

// ShutdownSave mocks base method.
func (m *MockCmdable) ShutdownSave(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShutdownSave", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ShutdownSave indicates an expected call of ShutdownSave.
func (mr *MockCmdableMockRecorder) ShutdownSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownSave), ctx)
}

// SlaveOf mocks base method.
func (m *MockCmdable) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// SlaveOf indicates an expected call of SlaveOf.
func (mr *MockCmdableMockRecorder) SlaveOf(ctx, host, port any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockCmdable)(nil).SlaveOf), ctx, host, port)
}

// SlowLogGet mocks base method.
func (m *MockCmdable) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlowLogGet", ctx, num)
	ret0, _ := ret[0].(*redis.SlowLogCmd)
	return ret0
}

// SlowLogGet indicates an expected call of SlowLogGet.
func (mr *MockCmdableMockRecorder) SlowLogGet(ctx, num any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockCmdable)(nil).SlowLogGet), ctx, num)
}

// Sort mocks base method.
func (m *MockCmdable) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sort", ctx, key, sort)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// Sort indicates an expected call of Sort.
func (mr *MockCmdableMockRecorder) Sort(ctx, key, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockCmdable)(nil).Sort), ctx, key, sort)
}

// SortInterfaces mocks base method.
func (m *MockCmdable) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// SortInterfaces indicates an expected call of SortInterfaces.
func (mr *MockCmdableMockRecorder) SortInterfaces(ctx, key, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockCmdable)(nil).SortInterfaces), ctx, key, sort)
}

// SortRO mocks base method.
func (m *MockCmdable) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SortRO", ctx, key, sort)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SortRO indicates an expected call of SortRO.
func (mr *MockCmdableMockRecorder) SortRO(ctx, key, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockCmdable)(nil).SortRO), ctx, key, sort)
}

// SortStore mocks base method.
func (m *MockCmdable) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SortStore indicates an expected call of SortStore.
func (mr *MockCmdableMockRecorder) SortStore(ctx, key, store, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockCmdable)(nil).SortStore), ctx, key, store, sort)
}

// StrLen mocks base method.
func (m *MockCmdable) StrLen(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StrLen", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// TDigestAdd mocks base method.
func (m *MockCmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestAdd", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TDigestAdd indicates an expected call of TDigestAdd.
func (mr *MockCmdableMockRecorder) TDigestAdd(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockCmdable)(nil).TDigestAdd), varargs...)
}

// TDigestByRank mocks base method.
func (m *MockCmdable) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range rank {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestByRank", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestByRank indicates an expected call of TDigestByRank.
func (mr *MockCmdableMockRecorder) TDigestByRank(ctx, key any, rank ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, rank...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockCmdable)(nil).TDigestByRank), varargs...)
}

// TDigestByRevRank mocks base method.
func (m *MockCmdable) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range rank {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestByRevRank indicates an expected call of TDigestByRevRank.
func (mr *MockCmdableMockRecorder) TDigestByRevRank(ctx, key any, rank ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, rank...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockCmdable)(nil).TDigestByRevRank), varargs...)
}

// TDigestCDF mocks base method.
func (m *MockCmdable) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestCDF", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestCDF indicates an expected call of TDigestCDF.
func (mr *MockCmdableMockRecorder) TDigestCDF(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockCmdable)(nil).TDigestCDF), varargs...)
}

// TDigestCreate mocks base method.
func (m *MockCmdable) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestCreate", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// TDigestCreateWithCompression mocks base method.
func (m *MockCmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression.
func (mr *MockCmdableMockRecorder) TDigestCreateWithCompression(ctx, key, compression any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockCmdable)(nil).TDigestCreateWithCompression), ctx, key, compression)
}

// TDigestInfo mocks base method.
func (m *MockCmdable) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestInfo", ctx, key)
	ret0, _ := ret[0].(*redis.TDigestInfoCmd)
	return ret0
}

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

// TDigestMax mocks base method.
func (m *MockCmdable) TDigestMax(ctx context.Context, key string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestMax", ctx, key)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

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

// TDigestMerge mocks base method.
func (m *MockCmdable) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey, options}
	for _, a := range sourceKeys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestMerge", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TDigestMerge indicates an expected call of TDigestMerge.
func (mr *MockCmdableMockRecorder) TDigestMerge(ctx, destKey, options any, sourceKeys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey, options}, sourceKeys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockCmdable)(nil).TDigestMerge), varargs...)
}

// TDigestMin mocks base method.
func (m *MockCmdable) TDigestMin(ctx context.Context, key string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestMin", ctx, key)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

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

// TDigestQuantile mocks base method.
func (m *MockCmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestQuantile", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestQuantile indicates an expected call of TDigestQuantile.
func (mr *MockCmdableMockRecorder) TDigestQuantile(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockCmdable)(nil).TDigestQuantile), varargs...)
}

// TDigestRank mocks base method.
func (m *MockCmdable) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestRank", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TDigestRank indicates an expected call of TDigestRank.
func (mr *MockCmdableMockRecorder) TDigestRank(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockCmdable)(nil).TDigestRank), varargs...)
}

// TDigestReset mocks base method.
func (m *MockCmdable) TDigestReset(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestReset", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// TDigestRevRank mocks base method.
func (m *MockCmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestRevRank", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TDigestRevRank indicates an expected call of TDigestRevRank.
func (mr *MockCmdableMockRecorder) TDigestRevRank(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockCmdable)(nil).TDigestRevRank), varargs...)
}

// TDigestTrimmedMean mocks base method.
func (m *MockCmdable) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean.
func (mr *MockCmdableMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockCmdable)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile)
}

// TSAdd mocks base method.
func (m *MockCmdable) TSAdd(ctx context.Context, key string, timestamp any, value float64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSAdd", ctx, key, timestamp, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSAdd indicates an expected call of TSAdd.
func (mr *MockCmdableMockRecorder) TSAdd(ctx, key, timestamp, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockCmdable)(nil).TSAdd), ctx, key, timestamp, value)
}

// TSAddWithArgs mocks base method.
func (m *MockCmdable) TSAddWithArgs(ctx context.Context, key string, timestamp any, value float64, options *redis.TSOptions) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSAddWithArgs", ctx, key, timestamp, value, options)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSAddWithArgs indicates an expected call of TSAddWithArgs.
func (mr *MockCmdableMockRecorder) TSAddWithArgs(ctx, key, timestamp, value, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSAddWithArgs), ctx, key, timestamp, value, options)
}

// TSAlter mocks base method.
func (m *MockCmdable) TSAlter(ctx context.Context, key string, options *redis.TSAlterOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSAlter", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSAlter indicates an expected call of TSAlter.
func (mr *MockCmdableMockRecorder) TSAlter(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockCmdable)(nil).TSAlter), ctx, key, options)
}

// TSCreate mocks base method.
func (m *MockCmdable) TSCreate(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreate", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// TSCreateRule mocks base method.
func (m *MockCmdable) TSCreateRule(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreateRule", ctx, sourceKey, destKey, aggregator, bucketDuration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSCreateRule indicates an expected call of TSCreateRule.
func (mr *MockCmdableMockRecorder) TSCreateRule(ctx, sourceKey, destKey, aggregator, bucketDuration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockCmdable)(nil).TSCreateRule), ctx, sourceKey, destKey, aggregator, bucketDuration)
}

// TSCreateRuleWithArgs mocks base method.
func (m *MockCmdable) TSCreateRuleWithArgs(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int, options *redis.TSCreateRuleOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", ctx, sourceKey, destKey, aggregator, bucketDuration, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs.
func (mr *MockCmdableMockRecorder) TSCreateRuleWithArgs(ctx, sourceKey, destKey, aggregator, bucketDuration, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSCreateRuleWithArgs), ctx, sourceKey, destKey, aggregator, bucketDuration, options)
}

// TSCreateWithArgs mocks base method.
func (m *MockCmdable) TSCreateWithArgs(ctx context.Context, key string, options *redis.TSOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreateWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSCreateWithArgs indicates an expected call of TSCreateWithArgs.
func (mr *MockCmdableMockRecorder) TSCreateWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSCreateWithArgs), ctx, key, options)
}

// TSDecrBy mocks base method.
func (m *MockCmdable) TSDecrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDecrBy", ctx, Key, timestamp)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSDecrBy indicates an expected call of TSDecrBy.
func (mr *MockCmdableMockRecorder) TSDecrBy(ctx, Key, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockCmdable)(nil).TSDecrBy), ctx, Key, timestamp)
}

// TSDecrByWithArgs mocks base method.
func (m *MockCmdable) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDecrByWithArgs", ctx, key, timestamp, options)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs.
func (mr *MockCmdableMockRecorder) TSDecrByWithArgs(ctx, key, timestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSDecrByWithArgs), ctx, key, timestamp, options)
}

// TSDel mocks base method.
func (m *MockCmdable) TSDel(ctx context.Context, Key string, fromTimestamp, toTimestamp int) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDel", ctx, Key, fromTimestamp, toTimestamp)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSDel indicates an expected call of TSDel.
func (mr *MockCmdableMockRecorder) TSDel(ctx, Key, fromTimestamp, toTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockCmdable)(nil).TSDel), ctx, Key, fromTimestamp, toTimestamp)
}

// TSDeleteRule mocks base method.
func (m *MockCmdable) TSDeleteRule(ctx context.Context, sourceKey, destKey string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDeleteRule", ctx, sourceKey, destKey)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSDeleteRule indicates an expected call of TSDeleteRule.
func (mr *MockCmdableMockRecorder) TSDeleteRule(ctx, sourceKey, destKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockCmdable)(nil).TSDeleteRule), ctx, sourceKey, destKey)
}

// TSGet mocks base method.
func (m *MockCmdable) TSGet(ctx context.Context, key string) *redis.TSTimestampValueCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSGet", ctx, key)
	ret0, _ := ret[0].(*redis.TSTimestampValueCmd)
	return ret0
}

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

// TSGetWithArgs mocks base method.
func (m *MockCmdable) TSGetWithArgs(ctx context.Context, key string, options *redis.TSGetOptions) *redis.TSTimestampValueCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSGetWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.TSTimestampValueCmd)
	return ret0
}

// TSGetWithArgs indicates an expected call of TSGetWithArgs.
func (mr *MockCmdableMockRecorder) TSGetWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSGetWithArgs), ctx, key, options)
}

// TSIncrBy mocks base method.
func (m *MockCmdable) TSIncrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSIncrBy", ctx, Key, timestamp)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSIncrBy indicates an expected call of TSIncrBy.
func (mr *MockCmdableMockRecorder) TSIncrBy(ctx, Key, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockCmdable)(nil).TSIncrBy), ctx, Key, timestamp)
}

// TSIncrByWithArgs mocks base method.
func (m *MockCmdable) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSIncrByWithArgs", ctx, key, timestamp, options)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs.
func (mr *MockCmdableMockRecorder) TSIncrByWithArgs(ctx, key, timestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSIncrByWithArgs), ctx, key, timestamp, options)
}

// TSInfo mocks base method.
func (m *MockCmdable) TSInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSInfo", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

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

// TSInfoWithArgs mocks base method.
func (m *MockCmdable) TSInfoWithArgs(ctx context.Context, key string, options *redis.TSInfoOptions) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSInfoWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

// TSInfoWithArgs indicates an expected call of TSInfoWithArgs.
func (mr *MockCmdableMockRecorder) TSInfoWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSInfoWithArgs), ctx, key, options)
}

// TSMAdd mocks base method.
func (m *MockCmdable) TSMAdd(ctx context.Context, ktvSlices [][]any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMAdd", ctx, ktvSlices)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TSMAdd indicates an expected call of TSMAdd.
func (mr *MockCmdableMockRecorder) TSMAdd(ctx, ktvSlices any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockCmdable)(nil).TSMAdd), ctx, ktvSlices)
}

// TSMGet mocks base method.
func (m *MockCmdable) TSMGet(ctx context.Context, filters []string) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMGet", ctx, filters)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMGet indicates an expected call of TSMGet.
func (mr *MockCmdableMockRecorder) TSMGet(ctx, filters any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockCmdable)(nil).TSMGet), ctx, filters)
}

// TSMGetWithArgs mocks base method.
func (m *MockCmdable) TSMGetWithArgs(ctx context.Context, filters []string, options *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMGetWithArgs", ctx, filters, options)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMGetWithArgs indicates an expected call of TSMGetWithArgs.
func (mr *MockCmdableMockRecorder) TSMGetWithArgs(ctx, filters, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMGetWithArgs), ctx, filters, options)
}

// TSMRange mocks base method.
func (m *MockCmdable) TSMRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRange", ctx, fromTimestamp, toTimestamp, filterExpr)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRange indicates an expected call of TSMRange.
func (mr *MockCmdableMockRecorder) TSMRange(ctx, fromTimestamp, toTimestamp, filterExpr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockCmdable)(nil).TSMRange), ctx, fromTimestamp, toTimestamp, filterExpr)
}

// TSMRangeWithArgs mocks base method.
func (m *MockCmdable) TSMRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs.
func (mr *MockCmdableMockRecorder) TSMRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options)
}

// TSMRevRange mocks base method.
func (m *MockCmdable) TSMRevRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRevRange", ctx, fromTimestamp, toTimestamp, filterExpr)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRevRange indicates an expected call of TSMRevRange.
func (mr *MockCmdableMockRecorder) TSMRevRange(ctx, fromTimestamp, toTimestamp, filterExpr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockCmdable)(nil).TSMRevRange), ctx, fromTimestamp, toTimestamp, filterExpr)
}

// TSMRevRangeWithArgs mocks base method.
func (m *MockCmdable) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs.
func (mr *MockCmdableMockRecorder) TSMRevRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMRevRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options)
}

// TSQueryIndex mocks base method.
func (m *MockCmdable) TSQueryIndex(ctx context.Context, filterExpr []string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSQueryIndex", ctx, filterExpr)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// TSQueryIndex indicates an expected call of TSQueryIndex.
func (mr *MockCmdableMockRecorder) TSQueryIndex(ctx, filterExpr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockCmdable)(nil).TSQueryIndex), ctx, filterExpr)
}

// TSRange mocks base method.
func (m *MockCmdable) TSRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRange", ctx, key, fromTimestamp, toTimestamp)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRange indicates an expected call of TSRange.
func (mr *MockCmdableMockRecorder) TSRange(ctx, key, fromTimestamp, toTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockCmdable)(nil).TSRange), ctx, key, fromTimestamp, toTimestamp)
}

// TSRangeWithArgs mocks base method.
func (m *MockCmdable) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRangeWithArgs indicates an expected call of TSRangeWithArgs.
func (mr *MockCmdableMockRecorder) TSRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options)
}

// TSRevRange mocks base method.
func (m *MockCmdable) TSRevRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRevRange", ctx, key, fromTimestamp, toTimestamp)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRevRange indicates an expected call of TSRevRange.
func (mr *MockCmdableMockRecorder) TSRevRange(ctx, key, fromTimestamp, toTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockCmdable)(nil).TSRevRange), ctx, key, fromTimestamp, toTimestamp)
}

// TSRevRangeWithArgs mocks base method.
func (m *MockCmdable) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRevRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs.
func (mr *MockCmdableMockRecorder) TSRevRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSRevRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options)
}

// TTL mocks base method.
func (m *MockCmdable) TTL(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TTL", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// Time mocks base method.
func (m *MockCmdable) Time(ctx context.Context) *redis.TimeCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Time", ctx)
	ret0, _ := ret[0].(*redis.TimeCmd)
	return ret0
}

// Time indicates an expected call of Time.
func (mr *MockCmdableMockRecorder) Time(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockCmdable)(nil).Time), ctx)
}

// TopKAdd mocks base method.
func (m *MockCmdable) TopKAdd(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKAdd", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// TopKAdd indicates an expected call of TopKAdd.
func (mr *MockCmdableMockRecorder) TopKAdd(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockCmdable)(nil).TopKAdd), varargs...)
}

// TopKCount mocks base method.
func (m *MockCmdable) TopKCount(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKCount", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TopKCount indicates an expected call of TopKCount.
func (mr *MockCmdableMockRecorder) TopKCount(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockCmdable)(nil).TopKCount), varargs...)
}

// TopKIncrBy mocks base method.
func (m *MockCmdable) TopKIncrBy(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKIncrBy", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// TopKIncrBy indicates an expected call of TopKIncrBy.
func (mr *MockCmdableMockRecorder) TopKIncrBy(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockCmdable)(nil).TopKIncrBy), varargs...)
}

// TopKInfo mocks base method.
func (m *MockCmdable) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKInfo", ctx, key)
	ret0, _ := ret[0].(*redis.TopKInfoCmd)
	return ret0
}

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

// TopKList mocks base method.
func (m *MockCmdable) TopKList(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKList", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// TopKListWithCount mocks base method.
func (m *MockCmdable) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringIntCmd)
	return ret0
}

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

// TopKQuery mocks base method.
func (m *MockCmdable) TopKQuery(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKQuery", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// TopKQuery indicates an expected call of TopKQuery.
func (mr *MockCmdableMockRecorder) TopKQuery(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockCmdable)(nil).TopKQuery), varargs...)
}

// TopKReserve mocks base method.
func (m *MockCmdable) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TopKReserve indicates an expected call of TopKReserve.
func (mr *MockCmdableMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockCmdable)(nil).TopKReserve), ctx, key, k)
}

// TopKReserveWithOptions mocks base method.
func (m *MockCmdable) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions.
func (mr *MockCmdableMockRecorder) TopKReserveWithOptions(ctx, key, k, width, depth, decay any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockCmdable)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay)
}

// Touch mocks base method.
func (m *MockCmdable) Touch(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Touch", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Touch indicates an expected call of Touch.
func (mr *MockCmdableMockRecorder) Touch(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockCmdable)(nil).Touch), varargs...)
}

// TxPipeline mocks base method.
func (m *MockCmdable) TxPipeline() redis.Pipeliner {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxPipeline")
	ret0, _ := ret[0].(redis.Pipeliner)
	return ret0
}

// TxPipeline indicates an expected call of TxPipeline.
func (mr *MockCmdableMockRecorder) TxPipeline() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockCmdable)(nil).TxPipeline))
}

// TxPipelined mocks base method.
func (m *MockCmdable) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxPipelined", ctx, fn)
	ret0, _ := ret[0].([]redis.Cmder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TxPipelined indicates an expected call of TxPipelined.
func (mr *MockCmdableMockRecorder) TxPipelined(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockCmdable)(nil).TxPipelined), ctx, fn)
}

// Type mocks base method.
func (m *MockCmdable) Type(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// Unlink mocks base method.
func (m *MockCmdable) Unlink(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Unlink", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Unlink indicates an expected call of Unlink.
func (mr *MockCmdableMockRecorder) Unlink(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockCmdable)(nil).Unlink), varargs...)
}

// VAdd mocks base method.
func (m *MockCmdable) VAdd(ctx context.Context, key, element string, val redis.Vector) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VAdd", ctx, key, element, val)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VAdd indicates an expected call of VAdd.
func (mr *MockCmdableMockRecorder) VAdd(ctx, key, element, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VAdd", reflect.TypeOf((*MockCmdable)(nil).VAdd), ctx, key, element, val)
}

// VAddWithArgs mocks base method.
func (m *MockCmdable) VAddWithArgs(ctx context.Context, key, element string, val redis.Vector, addArgs *redis.VAddArgs) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VAddWithArgs", ctx, key, element, val, addArgs)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VAddWithArgs indicates an expected call of VAddWithArgs.
func (mr *MockCmdableMockRecorder) VAddWithArgs(ctx, key, element, val, addArgs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VAddWithArgs", reflect.TypeOf((*MockCmdable)(nil).VAddWithArgs), ctx, key, element, val, addArgs)
}

// VCard mocks base method.
func (m *MockCmdable) VCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// VClearAttributes mocks base method.
func (m *MockCmdable) VClearAttributes(ctx context.Context, key, element string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VClearAttributes", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VClearAttributes indicates an expected call of VClearAttributes.
func (mr *MockCmdableMockRecorder) VClearAttributes(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VClearAttributes", reflect.TypeOf((*MockCmdable)(nil).VClearAttributes), ctx, key, element)
}

// VDim mocks base method.
func (m *MockCmdable) VDim(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VDim", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// VEmb mocks base method.
func (m *MockCmdable) VEmb(ctx context.Context, key, element string, raw bool) *redis.SliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VEmb", ctx, key, element, raw)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// VEmb indicates an expected call of VEmb.
func (mr *MockCmdableMockRecorder) VEmb(ctx, key, element, raw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VEmb", reflect.TypeOf((*MockCmdable)(nil).VEmb), ctx, key, element, raw)
}

// VGetAttr mocks base method.
func (m *MockCmdable) VGetAttr(ctx context.Context, key, element string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VGetAttr", ctx, key, element)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// VGetAttr indicates an expected call of VGetAttr.
func (mr *MockCmdableMockRecorder) VGetAttr(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VGetAttr", reflect.TypeOf((*MockCmdable)(nil).VGetAttr), ctx, key, element)
}

// VInfo mocks base method.
func (m *MockCmdable) VInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VInfo", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

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

// VLinks mocks base method.
func (m *MockCmdable) VLinks(ctx context.Context, key, element string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VLinks", ctx, key, element)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VLinks indicates an expected call of VLinks.
func (mr *MockCmdableMockRecorder) VLinks(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VLinks", reflect.TypeOf((*MockCmdable)(nil).VLinks), ctx, key, element)
}

// VLinksWithScores mocks base method.
func (m *MockCmdable) VLinksWithScores(ctx context.Context, key, element string) *redis.VectorScoreSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VLinksWithScores", ctx, key, element)
	ret0, _ := ret[0].(*redis.VectorScoreSliceCmd)
	return ret0
}

// VLinksWithScores indicates an expected call of VLinksWithScores.
func (mr *MockCmdableMockRecorder) VLinksWithScores(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VLinksWithScores", reflect.TypeOf((*MockCmdable)(nil).VLinksWithScores), ctx, key, element)
}

// VRandMember mocks base method.
func (m *MockCmdable) VRandMember(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRandMember", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// VRandMemberCount mocks base method.
func (m *MockCmdable) VRandMemberCount(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRandMemberCount", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VRandMemberCount indicates an expected call of VRandMemberCount.
func (mr *MockCmdableMockRecorder) VRandMemberCount(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRandMemberCount", reflect.TypeOf((*MockCmdable)(nil).VRandMemberCount), ctx, key, count)
}

// VRem mocks base method.
func (m *MockCmdable) VRem(ctx context.Context, key, element string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRem", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VRem indicates an expected call of VRem.
func (mr *MockCmdableMockRecorder) VRem(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRem", reflect.TypeOf((*MockCmdable)(nil).VRem), ctx, key, element)
}

// VSetAttr mocks base method.
func (m *MockCmdable) VSetAttr(ctx context.Context, key, element string, attr any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSetAttr", ctx, key, element, attr)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VSetAttr indicates an expected call of VSetAttr.
func (mr *MockCmdableMockRecorder) VSetAttr(ctx, key, element, attr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSetAttr", reflect.TypeOf((*MockCmdable)(nil).VSetAttr), ctx, key, element, attr)
}

// VSim mocks base method.
func (m *MockCmdable) VSim(ctx context.Context, key string, val redis.Vector) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSim", ctx, key, val)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VSim indicates an expected call of VSim.
func (mr *MockCmdableMockRecorder) VSim(ctx, key, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSim", reflect.TypeOf((*MockCmdable)(nil).VSim), ctx, key, val)
}

// VSimWithArgs mocks base method.
func (m *MockCmdable) VSimWithArgs(ctx context.Context, key string, val redis.Vector, args *redis.VSimArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSimWithArgs", ctx, key, val, args)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VSimWithArgs indicates an expected call of VSimWithArgs.
func (mr *MockCmdableMockRecorder) VSimWithArgs(ctx, key, val, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSimWithArgs", reflect.TypeOf((*MockCmdable)(nil).VSimWithArgs), ctx, key, val, args)
}

// VSimWithArgsWithScores mocks base method.
func (m *MockCmdable) VSimWithArgsWithScores(ctx context.Context, key string, val redis.Vector, args *redis.VSimArgs) *redis.VectorScoreSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSimWithArgsWithScores", ctx, key, val, args)
	ret0, _ := ret[0].(*redis.VectorScoreSliceCmd)
	return ret0
}

// VSimWithArgsWithScores indicates an expected call of VSimWithArgsWithScores.
func (mr *MockCmdableMockRecorder) VSimWithArgsWithScores(ctx, key, val, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSimWithArgsWithScores", reflect.TypeOf((*MockCmdable)(nil).VSimWithArgsWithScores), ctx, key, val, args)
}

// VSimWithScores mocks base method.
func (m *MockCmdable) VSimWithScores(ctx context.Context, key string, val redis.Vector) *redis.VectorScoreSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSimWithScores", ctx, key, val)
	ret0, _ := ret[0].(*redis.VectorScoreSliceCmd)
	return ret0
}

// VSimWithScores indicates an expected call of VSimWithScores.
func (mr *MockCmdableMockRecorder) VSimWithScores(ctx, key, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSimWithScores", reflect.TypeOf((*MockCmdable)(nil).VSimWithScores), ctx, key, val)
}

// XAck mocks base method.
func (m *MockCmdable) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream, group}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XAck", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XAck indicates an expected call of XAck.
func (mr *MockCmdableMockRecorder) XAck(ctx, stream, group any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream, group}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockCmdable)(nil).XAck), varargs...)
}

// XAckDel mocks base method.
func (m *MockCmdable) XAckDel(ctx context.Context, stream, group, mode string, ids ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream, group, mode}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XAckDel", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// XAckDel indicates an expected call of XAckDel.
func (mr *MockCmdableMockRecorder) XAckDel(ctx, stream, group, mode any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream, group, mode}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAckDel", reflect.TypeOf((*MockCmdable)(nil).XAckDel), varargs...)
}

// XAdd mocks base method.
func (m *MockCmdable) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XAdd", ctx, a)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// XAdd indicates an expected call of XAdd.
func (mr *MockCmdableMockRecorder) XAdd(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockCmdable)(nil).XAdd), ctx, a)
}

// XAutoClaim mocks base method.
func (m *MockCmdable) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XAutoClaim", ctx, a)
	ret0, _ := ret[0].(*redis.XAutoClaimCmd)
	return ret0
}

// XAutoClaim indicates an expected call of XAutoClaim.
func (mr *MockCmdableMockRecorder) XAutoClaim(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockCmdable)(nil).XAutoClaim), ctx, a)
}

// XAutoClaimJustID mocks base method.
func (m *MockCmdable) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a)
	ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd)
	return ret0
}

// XAutoClaimJustID indicates an expected call of XAutoClaimJustID.
func (mr *MockCmdableMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XAutoClaimJustID), ctx, a)
}

// XClaim mocks base method.
func (m *MockCmdable) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XClaim", ctx, a)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XClaim indicates an expected call of XClaim.
func (mr *MockCmdableMockRecorder) XClaim(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockCmdable)(nil).XClaim), ctx, a)
}

// XClaimJustID mocks base method.
func (m *MockCmdable) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XClaimJustID", ctx, a)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// XClaimJustID indicates an expected call of XClaimJustID.
func (mr *MockCmdableMockRecorder) XClaimJustID(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XClaimJustID), ctx, a)
}

// XDel mocks base method.
func (m *MockCmdable) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XDel", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XDel indicates an expected call of XDel.
func (mr *MockCmdableMockRecorder) XDel(ctx, stream any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockCmdable)(nil).XDel), varargs...)
}

// XDelEx mocks base method.
func (m *MockCmdable) XDelEx(ctx context.Context, stream, mode string, ids ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream, mode}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XDelEx", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// XDelEx indicates an expected call of XDelEx.
func (mr *MockCmdableMockRecorder) XDelEx(ctx, stream, mode any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream, mode}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDelEx", reflect.TypeOf((*MockCmdable)(nil).XDelEx), varargs...)
}

// XGroupCreate mocks base method.
func (m *MockCmdable) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// XGroupCreate indicates an expected call of XGroupCreate.
func (mr *MockCmdableMockRecorder) XGroupCreate(ctx, stream, group, start any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockCmdable)(nil).XGroupCreate), ctx, stream, group, start)
}

// XGroupCreateConsumer mocks base method.
func (m *MockCmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer.
func (mr *MockCmdableMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateConsumer), ctx, stream, group, consumer)
}

// XGroupCreateMkStream mocks base method.
func (m *MockCmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream.
func (mr *MockCmdableMockRecorder) XGroupCreateMkStream(ctx, stream, group, start any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateMkStream), ctx, stream, group, start)
}

// XGroupDelConsumer mocks base method.
func (m *MockCmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XGroupDelConsumer indicates an expected call of XGroupDelConsumer.
func (mr *MockCmdableMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupDelConsumer), ctx, stream, group, consumer)
}

// XGroupDestroy mocks base method.
func (m *MockCmdable) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XGroupDestroy indicates an expected call of XGroupDestroy.
func (mr *MockCmdableMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockCmdable)(nil).XGroupDestroy), ctx, stream, group)
}

// XGroupSetID mocks base method.
func (m *MockCmdable) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// XGroupSetID indicates an expected call of XGroupSetID.
func (mr *MockCmdableMockRecorder) XGroupSetID(ctx, stream, group, start any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockCmdable)(nil).XGroupSetID), ctx, stream, group, start)
}

// XInfoConsumers mocks base method.
func (m *MockCmdable) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group)
	ret0, _ := ret[0].(*redis.XInfoConsumersCmd)
	return ret0
}

// XInfoConsumers indicates an expected call of XInfoConsumers.
func (mr *MockCmdableMockRecorder) XInfoConsumers(ctx, key, group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockCmdable)(nil).XInfoConsumers), ctx, key, group)
}

// XInfoGroups mocks base method.
func (m *MockCmdable) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoGroups", ctx, key)
	ret0, _ := ret[0].(*redis.XInfoGroupsCmd)
	return ret0
}

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

// XInfoStream mocks base method.
func (m *MockCmdable) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoStream", ctx, key)
	ret0, _ := ret[0].(*redis.XInfoStreamCmd)
	return ret0
}

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

// XInfoStreamFull mocks base method.
func (m *MockCmdable) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count)
	ret0, _ := ret[0].(*redis.XInfoStreamFullCmd)
	return ret0
}

// XInfoStreamFull indicates an expected call of XInfoStreamFull.
func (mr *MockCmdableMockRecorder) XInfoStreamFull(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockCmdable)(nil).XInfoStreamFull), ctx, key, count)
}

// XLen mocks base method.
func (m *MockCmdable) XLen(ctx context.Context, stream string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XLen", ctx, stream)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XLen indicates an expected call of XLen.
func (mr *MockCmdableMockRecorder) XLen(ctx, stream any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockCmdable)(nil).XLen), ctx, stream)
}

// XPending mocks base method.
func (m *MockCmdable) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XPending", ctx, stream, group)
	ret0, _ := ret[0].(*redis.XPendingCmd)
	return ret0
}

// XPending indicates an expected call of XPending.
func (mr *MockCmdableMockRecorder) XPending(ctx, stream, group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockCmdable)(nil).XPending), ctx, stream, group)
}

// XPendingExt mocks base method.
func (m *MockCmdable) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XPendingExt", ctx, a)
	ret0, _ := ret[0].(*redis.XPendingExtCmd)
	return ret0
}

// XPendingExt indicates an expected call of XPendingExt.
func (mr *MockCmdableMockRecorder) XPendingExt(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockCmdable)(nil).XPendingExt), ctx, a)
}

// XRange mocks base method.
func (m *MockCmdable) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRange indicates an expected call of XRange.
func (mr *MockCmdableMockRecorder) XRange(ctx, stream, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockCmdable)(nil).XRange), ctx, stream, start, stop)
}

// XRangeN mocks base method.
func (m *MockCmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRangeN indicates an expected call of XRangeN.
func (mr *MockCmdableMockRecorder) XRangeN(ctx, stream, start, stop, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockCmdable)(nil).XRangeN), ctx, stream, start, stop, count)
}

// XRead mocks base method.
func (m *MockCmdable) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRead", ctx, a)
	ret0, _ := ret[0].(*redis.XStreamSliceCmd)
	return ret0
}

// XRead indicates an expected call of XRead.
func (mr *MockCmdableMockRecorder) XRead(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockCmdable)(nil).XRead), ctx, a)
}

// XReadGroup mocks base method.
func (m *MockCmdable) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XReadGroup", ctx, a)
	ret0, _ := ret[0].(*redis.XStreamSliceCmd)
	return ret0
}

// XReadGroup indicates an expected call of XReadGroup.
func (mr *MockCmdableMockRecorder) XReadGroup(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockCmdable)(nil).XReadGroup), ctx, a)
}

// XReadStreams mocks base method.
func (m *MockCmdable) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range streams {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XReadStreams", varargs...)
	ret0, _ := ret[0].(*redis.XStreamSliceCmd)
	return ret0
}

// XReadStreams indicates an expected call of XReadStreams.
func (mr *MockCmdableMockRecorder) XReadStreams(ctx any, streams ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, streams...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockCmdable)(nil).XReadStreams), varargs...)
}

// XRevRange mocks base method.
func (m *MockCmdable) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRevRange indicates an expected call of XRevRange.
func (mr *MockCmdableMockRecorder) XRevRange(ctx, stream, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockCmdable)(nil).XRevRange), ctx, stream, start, stop)
}

// XRevRangeN mocks base method.
func (m *MockCmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRevRangeN indicates an expected call of XRevRangeN.
func (mr *MockCmdableMockRecorder) XRevRangeN(ctx, stream, start, stop, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockCmdable)(nil).XRevRangeN), ctx, stream, start, stop, count)
}

// XTrimMaxLen mocks base method.
func (m *MockCmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLen indicates an expected call of XTrimMaxLen.
func (mr *MockCmdableMockRecorder) XTrimMaxLen(ctx, key, maxLen any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLen), ctx, key, maxLen)
}

// XTrimMaxLenApprox mocks base method.
func (m *MockCmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox.
func (mr *MockCmdableMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit)
}

// XTrimMaxLenApproxMode mocks base method.
func (m *MockCmdable) XTrimMaxLenApproxMode(ctx context.Context, key string, maxLen, limit int64, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLenApproxMode", ctx, key, maxLen, limit, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLenApproxMode indicates an expected call of XTrimMaxLenApproxMode.
func (mr *MockCmdableMockRecorder) XTrimMaxLenApproxMode(ctx, key, maxLen, limit, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApproxMode", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLenApproxMode), ctx, key, maxLen, limit, mode)
}

// XTrimMaxLenMode mocks base method.
func (m *MockCmdable) XTrimMaxLenMode(ctx context.Context, key string, maxLen int64, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLenMode", ctx, key, maxLen, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLenMode indicates an expected call of XTrimMaxLenMode.
func (mr *MockCmdableMockRecorder) XTrimMaxLenMode(ctx, key, maxLen, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenMode", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLenMode), ctx, key, maxLen, mode)
}

// XTrimMinID mocks base method.
func (m *MockCmdable) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinID indicates an expected call of XTrimMinID.
func (mr *MockCmdableMockRecorder) XTrimMinID(ctx, key, minID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockCmdable)(nil).XTrimMinID), ctx, key, minID)
}

// XTrimMinIDApprox mocks base method.
func (m *MockCmdable) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox.
func (mr *MockCmdableMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMinIDApprox), ctx, key, minID, limit)
}

// XTrimMinIDApproxMode mocks base method.
func (m *MockCmdable) XTrimMinIDApproxMode(ctx context.Context, key, minID string, limit int64, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinIDApproxMode", ctx, key, minID, limit, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinIDApproxMode indicates an expected call of XTrimMinIDApproxMode.
func (mr *MockCmdableMockRecorder) XTrimMinIDApproxMode(ctx, key, minID, limit, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApproxMode", reflect.TypeOf((*MockCmdable)(nil).XTrimMinIDApproxMode), ctx, key, minID, limit, mode)
}

// XTrimMinIDMode mocks base method.
func (m *MockCmdable) XTrimMinIDMode(ctx context.Context, key, minID, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinIDMode", ctx, key, minID, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinIDMode indicates an expected call of XTrimMinIDMode.
func (mr *MockCmdableMockRecorder) XTrimMinIDMode(ctx, key, minID, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDMode", reflect.TypeOf((*MockCmdable)(nil).XTrimMinIDMode), ctx, key, minID, mode)
}

// ZAdd mocks base method.
func (m *MockCmdable) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAdd indicates an expected call of ZAdd.
func (mr *MockCmdableMockRecorder) ZAdd(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockCmdable)(nil).ZAdd), varargs...)
}

// ZAddArgs mocks base method.
func (m *MockCmdable) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddArgs indicates an expected call of ZAddArgs.
func (mr *MockCmdableMockRecorder) ZAddArgs(ctx, key, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockCmdable)(nil).ZAddArgs), ctx, key, args)
}

// ZAddArgsIncr mocks base method.
func (m *MockCmdable) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// ZAddArgsIncr indicates an expected call of ZAddArgsIncr.
func (mr *MockCmdableMockRecorder) ZAddArgsIncr(ctx, key, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockCmdable)(nil).ZAddArgsIncr), ctx, key, args)
}

// ZAddGT mocks base method.
func (m *MockCmdable) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddGT", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddGT indicates an expected call of ZAddGT.
func (mr *MockCmdableMockRecorder) ZAddGT(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockCmdable)(nil).ZAddGT), varargs...)
}

// ZAddLT mocks base method.
func (m *MockCmdable) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddLT", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddLT indicates an expected call of ZAddLT.
func (mr *MockCmdableMockRecorder) ZAddLT(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockCmdable)(nil).ZAddLT), varargs...)
}

// ZAddNX mocks base method.
func (m *MockCmdable) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddNX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddNX indicates an expected call of ZAddNX.
func (mr *MockCmdableMockRecorder) ZAddNX(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockCmdable)(nil).ZAddNX), varargs...)
}

// ZAddXX mocks base method.
func (m *MockCmdable) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddXX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddXX indicates an expected call of ZAddXX.
func (mr *MockCmdableMockRecorder) ZAddXX(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockCmdable)(nil).ZAddXX), varargs...)
}

// ZCard mocks base method.
func (m *MockCmdable) ZCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// ZCount mocks base method.
func (m *MockCmdable) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZCount indicates an expected call of ZCount.
func (mr *MockCmdableMockRecorder) ZCount(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockCmdable)(nil).ZCount), ctx, key, min, max)
}

// ZDiff mocks base method.
func (m *MockCmdable) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZDiff", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZDiff indicates an expected call of ZDiff.
func (mr *MockCmdableMockRecorder) ZDiff(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockCmdable)(nil).ZDiff), varargs...)
}

// ZDiffStore mocks base method.
func (m *MockCmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZDiffStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZDiffStore indicates an expected call of ZDiffStore.
func (mr *MockCmdableMockRecorder) ZDiffStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockCmdable)(nil).ZDiffStore), varargs...)
}

// ZDiffWithScores mocks base method.
func (m *MockCmdable) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZDiffWithScores indicates an expected call of ZDiffWithScores.
func (mr *MockCmdableMockRecorder) ZDiffWithScores(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockCmdable)(nil).ZDiffWithScores), varargs...)
}

// ZIncrBy mocks base method.
func (m *MockCmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// ZIncrBy indicates an expected call of ZIncrBy.
func (mr *MockCmdableMockRecorder) ZIncrBy(ctx, key, increment, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockCmdable)(nil).ZIncrBy), ctx, key, increment, member)
}

// ZInter mocks base method.
func (m *MockCmdable) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZInter", ctx, store)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZInter indicates an expected call of ZInter.
func (mr *MockCmdableMockRecorder) ZInter(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockCmdable)(nil).ZInter), ctx, store)
}

// ZInterCard mocks base method.
func (m *MockCmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, limit}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZInterCard", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZInterCard indicates an expected call of ZInterCard.
func (mr *MockCmdableMockRecorder) ZInterCard(ctx, limit any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, limit}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockCmdable)(nil).ZInterCard), varargs...)
}

// ZInterStore mocks base method.
func (m *MockCmdable) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZInterStore indicates an expected call of ZInterStore.
func (mr *MockCmdableMockRecorder) ZInterStore(ctx, destination, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockCmdable)(nil).ZInterStore), ctx, destination, store)
}

// ZInterWithScores mocks base method.
func (m *MockCmdable) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZInterWithScores indicates an expected call of ZInterWithScores.
func (mr *MockCmdableMockRecorder) ZInterWithScores(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockCmdable)(nil).ZInterWithScores), ctx, store)
}

// ZLexCount mocks base method.
func (m *MockCmdable) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZLexCount indicates an expected call of ZLexCount.
func (mr *MockCmdableMockRecorder) ZLexCount(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockCmdable)(nil).ZLexCount), ctx, key, min, max)
}

// ZMPop mocks base method.
func (m *MockCmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, order, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZMPop", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd)
	return ret0
}

// ZMPop indicates an expected call of ZMPop.
func (mr *MockCmdableMockRecorder) ZMPop(ctx, order, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, order, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockCmdable)(nil).ZMPop), varargs...)
}

// ZMScore mocks base method.
func (m *MockCmdable) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZMScore", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// ZMScore indicates an expected call of ZMScore.
func (mr *MockCmdableMockRecorder) ZMScore(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockCmdable)(nil).ZMScore), varargs...)
}

// ZPopMax mocks base method.
func (m *MockCmdable) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range count {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZPopMax", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZPopMax indicates an expected call of ZPopMax.
func (mr *MockCmdableMockRecorder) ZPopMax(ctx, key any, count ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, count...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockCmdable)(nil).ZPopMax), varargs...)
}

// ZPopMin mocks base method.
func (m *MockCmdable) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range count {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZPopMin", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZPopMin indicates an expected call of ZPopMin.
func (mr *MockCmdableMockRecorder) ZPopMin(ctx, key any, count ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, count...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockCmdable)(nil).ZPopMin), varargs...)
}

// ZRandMember mocks base method.
func (m *MockCmdable) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRandMember indicates an expected call of ZRandMember.
func (mr *MockCmdableMockRecorder) ZRandMember(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockCmdable)(nil).ZRandMember), ctx, key, count)
}

// ZRandMemberWithScores mocks base method.
func (m *MockCmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores.
func (mr *MockCmdableMockRecorder) ZRandMemberWithScores(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRandMemberWithScores), ctx, key, count)
}

// ZRange mocks base method.
func (m *MockCmdable) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRange indicates an expected call of ZRange.
func (mr *MockCmdableMockRecorder) ZRange(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockCmdable)(nil).ZRange), ctx, key, start, stop)
}

// ZRangeArgs mocks base method.
func (m *MockCmdable) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRangeArgs indicates an expected call of ZRangeArgs.
func (mr *MockCmdableMockRecorder) ZRangeArgs(ctx, z any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgs), ctx, z)
}

// ZRangeArgsWithScores mocks base method.
func (m *MockCmdable) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores.
func (mr *MockCmdableMockRecorder) ZRangeArgsWithScores(ctx, z any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgsWithScores), ctx, z)
}

// ZRangeByLex mocks base method.
func (m *MockCmdable) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRangeByLex indicates an expected call of ZRangeByLex.
func (mr *MockCmdableMockRecorder) ZRangeByLex(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRangeByLex), ctx, key, opt)
}

// ZRangeByScore mocks base method.
func (m *MockCmdable) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRangeByScore indicates an expected call of ZRangeByScore.
func (mr *MockCmdableMockRecorder) ZRangeByScore(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScore), ctx, key, opt)
}

// ZRangeByScoreWithScores mocks base method.
func (m *MockCmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores.
func (mr *MockCmdableMockRecorder) ZRangeByScoreWithScores(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScoreWithScores), ctx, key, opt)
}

// ZRangeStore mocks base method.
func (m *MockCmdable) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRangeStore indicates an expected call of ZRangeStore.
func (mr *MockCmdableMockRecorder) ZRangeStore(ctx, dst, z any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockCmdable)(nil).ZRangeStore), ctx, dst, z)
}

// ZRangeWithScores mocks base method.
func (m *MockCmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRangeWithScores indicates an expected call of ZRangeWithScores.
func (mr *MockCmdableMockRecorder) ZRangeWithScores(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeWithScores), ctx, key, start, stop)
}

// ZRank mocks base method.
func (m *MockCmdable) ZRank(ctx context.Context, key, member string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRank", ctx, key, member)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRank indicates an expected call of ZRank.
func (mr *MockCmdableMockRecorder) ZRank(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockCmdable)(nil).ZRank), ctx, key, member)
}

// ZRankWithScore mocks base method.
func (m *MockCmdable) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member)
	ret0, _ := ret[0].(*redis.RankWithScoreCmd)
	return ret0
}

// ZRankWithScore indicates an expected call of ZRankWithScore.
func (mr *MockCmdableMockRecorder) ZRankWithScore(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRankWithScore), ctx, key, member)
}

// ZRem mocks base method.
func (m *MockCmdable) ZRem(ctx context.Context, key string, members ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZRem", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRem indicates an expected call of ZRem.
func (mr *MockCmdableMockRecorder) ZRem(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockCmdable)(nil).ZRem), varargs...)
}

// ZRemRangeByLex mocks base method.
func (m *MockCmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRemRangeByLex indicates an expected call of ZRemRangeByLex.
func (mr *MockCmdableMockRecorder) ZRemRangeByLex(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByLex), ctx, key, min, max)
}

// ZRemRangeByRank mocks base method.
func (m *MockCmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRemRangeByRank indicates an expected call of ZRemRangeByRank.
func (mr *MockCmdableMockRecorder) ZRemRangeByRank(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByRank), ctx, key, start, stop)
}

// ZRemRangeByScore mocks base method.
func (m *MockCmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRemRangeByScore indicates an expected call of ZRemRangeByScore.
func (mr *MockCmdableMockRecorder) ZRemRangeByScore(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByScore), ctx, key, min, max)
}

// ZRevRange mocks base method.
func (m *MockCmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRevRange indicates an expected call of ZRevRange.
func (mr *MockCmdableMockRecorder) ZRevRange(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockCmdable)(nil).ZRevRange), ctx, key, start, stop)
}

// ZRevRangeByLex mocks base method.
func (m *MockCmdable) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRevRangeByLex indicates an expected call of ZRevRangeByLex.
func (mr *MockCmdableMockRecorder) ZRevRangeByLex(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByLex), ctx, key, opt)
}

// ZRevRangeByScore mocks base method.
func (m *MockCmdable) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRevRangeByScore indicates an expected call of ZRevRangeByScore.
func (mr *MockCmdableMockRecorder) ZRevRangeByScore(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScore), ctx, key, opt)
}

// ZRevRangeByScoreWithScores mocks base method.
func (m *MockCmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores.
func (mr *MockCmdableMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScoreWithScores), ctx, key, opt)
}

// ZRevRangeWithScores mocks base method.
func (m *MockCmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores.
func (mr *MockCmdableMockRecorder) ZRevRangeWithScores(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeWithScores), ctx, key, start, stop)
}

// ZRevRank mocks base method.
func (m *MockCmdable) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRevRank indicates an expected call of ZRevRank.
func (mr *MockCmdableMockRecorder) ZRevRank(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockCmdable)(nil).ZRevRank), ctx, key, member)
}

// ZRevRankWithScore mocks base method.
func (m *MockCmdable) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member)
	ret0, _ := ret[0].(*redis.RankWithScoreCmd)
	return ret0
}

// ZRevRankWithScore indicates an expected call of ZRevRankWithScore.
func (mr *MockCmdableMockRecorder) ZRevRankWithScore(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRankWithScore), ctx, key, member)
}

// ZScan mocks base method.
func (m *MockCmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// ZScan indicates an expected call of ZScan.
func (mr *MockCmdableMockRecorder) ZScan(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockCmdable)(nil).ZScan), ctx, key, cursor, match, count)
}

// ZScore mocks base method.
func (m *MockCmdable) ZScore(ctx context.Context, key, member string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZScore", ctx, key, member)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// ZScore indicates an expected call of ZScore.
func (mr *MockCmdableMockRecorder) ZScore(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockCmdable)(nil).ZScore), ctx, key, member)
}

// ZUnion mocks base method.
func (m *MockCmdable) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZUnion", ctx, store)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZUnion indicates an expected call of ZUnion.
func (mr *MockCmdableMockRecorder) ZUnion(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockCmdable)(nil).ZUnion), ctx, store)
}

// ZUnionStore mocks base method.
func (m *MockCmdable) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZUnionStore indicates an expected call of ZUnionStore.
func (mr *MockCmdableMockRecorder) ZUnionStore(ctx, dest, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockCmdable)(nil).ZUnionStore), ctx, dest, store)
}

// ZUnionWithScores mocks base method.
func (m *MockCmdable) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZUnionWithScores indicates an expected call of ZUnionWithScores.
func (mr *MockCmdableMockRecorder) ZUnionWithScores(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockCmdable)(nil).ZUnionWithScores), ctx, store)
}

// MockUniversalClient is a mock of UniversalClient interface.
type MockUniversalClient struct {
	ctrl     *gomock.Controller
	recorder *MockUniversalClientMockRecorder
	isgomock struct{}
}

// MockUniversalClientMockRecorder is the mock recorder for MockUniversalClient.
type MockUniversalClientMockRecorder struct {
	mock *MockUniversalClient
}

// NewMockUniversalClient creates a new mock instance.
func NewMockUniversalClient(ctrl *gomock.Controller) *MockUniversalClient {
	mock := &MockUniversalClient{ctrl: ctrl}
	mock.recorder = &MockUniversalClientMockRecorder{mock}
	return mock
}

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

// ACLCat mocks base method.
func (m *MockUniversalClient) ACLCat(ctx context.Context) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLCat", ctx)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ACLCat indicates an expected call of ACLCat.
func (mr *MockUniversalClientMockRecorder) ACLCat(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLCat", reflect.TypeOf((*MockUniversalClient)(nil).ACLCat), ctx)
}

// ACLCatArgs mocks base method.
func (m *MockUniversalClient) ACLCatArgs(ctx context.Context, options *redis.ACLCatArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLCatArgs", ctx, options)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ACLCatArgs indicates an expected call of ACLCatArgs.
func (mr *MockUniversalClientMockRecorder) ACLCatArgs(ctx, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLCatArgs", reflect.TypeOf((*MockUniversalClient)(nil).ACLCatArgs), ctx, options)
}

// ACLDelUser mocks base method.
func (m *MockUniversalClient) ACLDelUser(ctx context.Context, username string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLDelUser", ctx, username)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ACLDelUser indicates an expected call of ACLDelUser.
func (mr *MockUniversalClientMockRecorder) ACLDelUser(ctx, username any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDelUser", reflect.TypeOf((*MockUniversalClient)(nil).ACLDelUser), ctx, username)
}

// ACLDryRun mocks base method.
func (m *MockUniversalClient) ACLDryRun(ctx context.Context, username string, command ...any) *redis.StringCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, username}
	for _, a := range command {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ACLDryRun", varargs...)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ACLDryRun indicates an expected call of ACLDryRun.
func (mr *MockUniversalClientMockRecorder) ACLDryRun(ctx, username any, command ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, username}, command...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockUniversalClient)(nil).ACLDryRun), varargs...)
}

// ACLList mocks base method.
func (m *MockUniversalClient) ACLList(ctx context.Context) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLList", ctx)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ACLList indicates an expected call of ACLList.
func (mr *MockUniversalClientMockRecorder) ACLList(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLList", reflect.TypeOf((*MockUniversalClient)(nil).ACLList), ctx)
}

// ACLLog mocks base method.
func (m *MockUniversalClient) ACLLog(ctx context.Context, count int64) *redis.ACLLogCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLLog", ctx, count)
	ret0, _ := ret[0].(*redis.ACLLogCmd)
	return ret0
}

// ACLLog indicates an expected call of ACLLog.
func (mr *MockUniversalClientMockRecorder) ACLLog(ctx, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockUniversalClient)(nil).ACLLog), ctx, count)
}

// ACLLogReset mocks base method.
func (m *MockUniversalClient) ACLLogReset(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ACLLogReset", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ACLLogReset indicates an expected call of ACLLogReset.
func (mr *MockUniversalClientMockRecorder) ACLLogReset(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockUniversalClient)(nil).ACLLogReset), ctx)
}

// ACLSetUser mocks base method.
func (m *MockUniversalClient) ACLSetUser(ctx context.Context, username string, rules ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, username}
	for _, a := range rules {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ACLSetUser", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ACLSetUser indicates an expected call of ACLSetUser.
func (mr *MockUniversalClientMockRecorder) ACLSetUser(ctx, username any, rules ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, username}, rules...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLSetUser", reflect.TypeOf((*MockUniversalClient)(nil).ACLSetUser), varargs...)
}

// AddHook mocks base method.
func (m *MockUniversalClient) AddHook(arg0 redis.Hook) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHook", arg0)
}

// AddHook indicates an expected call of AddHook.
func (mr *MockUniversalClientMockRecorder) AddHook(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHook", reflect.TypeOf((*MockUniversalClient)(nil).AddHook), arg0)
}

// Append mocks base method.
func (m *MockUniversalClient) Append(ctx context.Context, key, value string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Append", ctx, key, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Append indicates an expected call of Append.
func (mr *MockUniversalClientMockRecorder) Append(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockUniversalClient)(nil).Append), ctx, key, value)
}

// BFAdd mocks base method.
func (m *MockUniversalClient) BFAdd(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFAdd", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// BFAdd indicates an expected call of BFAdd.
func (mr *MockUniversalClientMockRecorder) BFAdd(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockUniversalClient)(nil).BFAdd), ctx, key, element)
}

// BFCard mocks base method.
func (m *MockUniversalClient) BFCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// BFExists mocks base method.
func (m *MockUniversalClient) BFExists(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFExists", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// BFExists indicates an expected call of BFExists.
func (mr *MockUniversalClientMockRecorder) BFExists(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockUniversalClient)(nil).BFExists), ctx, key, element)
}

// BFInfo mocks base method.
func (m *MockUniversalClient) BFInfo(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfo", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoArg mocks base method.
func (m *MockUniversalClient) BFInfoArg(ctx context.Context, key, option string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoArg", ctx, key, option)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

// BFInfoArg indicates an expected call of BFInfoArg.
func (mr *MockUniversalClientMockRecorder) BFInfoArg(ctx, key, option any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoArg), ctx, key, option)
}

// BFInfoCapacity mocks base method.
func (m *MockUniversalClient) BFInfoCapacity(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoCapacity", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoExpansion mocks base method.
func (m *MockUniversalClient) BFInfoExpansion(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoExpansion", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoFilters mocks base method.
func (m *MockUniversalClient) BFInfoFilters(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoFilters", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoItems mocks base method.
func (m *MockUniversalClient) BFInfoItems(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoItems", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInfoSize mocks base method.
func (m *MockUniversalClient) BFInfoSize(ctx context.Context, key string) *redis.BFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFInfoSize", ctx, key)
	ret0, _ := ret[0].(*redis.BFInfoCmd)
	return ret0
}

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

// BFInsert mocks base method.
func (m *MockUniversalClient) BFInsert(ctx context.Context, key string, options *redis.BFInsertOptions, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BFInsert", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// BFInsert indicates an expected call of BFInsert.
func (mr *MockUniversalClientMockRecorder) BFInsert(ctx, key, options any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockUniversalClient)(nil).BFInsert), varargs...)
}

// BFLoadChunk mocks base method.
func (m *MockUniversalClient) BFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFLoadChunk", ctx, key, iterator, data)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFLoadChunk indicates an expected call of BFLoadChunk.
func (mr *MockUniversalClientMockRecorder) BFLoadChunk(ctx, key, iterator, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockUniversalClient)(nil).BFLoadChunk), ctx, key, iterator, data)
}

// BFMAdd mocks base method.
func (m *MockUniversalClient) BFMAdd(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BFMAdd", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// BFMAdd indicates an expected call of BFMAdd.
func (mr *MockUniversalClientMockRecorder) BFMAdd(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockUniversalClient)(nil).BFMAdd), varargs...)
}

// BFMExists mocks base method.
func (m *MockUniversalClient) BFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BFMExists", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// BFMExists indicates an expected call of BFMExists.
func (mr *MockUniversalClientMockRecorder) BFMExists(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockUniversalClient)(nil).BFMExists), varargs...)
}

// BFReserve mocks base method.
func (m *MockUniversalClient) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserve", ctx, key, errorRate, capacity)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserve indicates an expected call of BFReserve.
func (mr *MockUniversalClientMockRecorder) BFReserve(ctx, key, errorRate, capacity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockUniversalClient)(nil).BFReserve), ctx, key, errorRate, capacity)
}

// BFReserveExpansion mocks base method.
func (m *MockUniversalClient) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserveExpansion", ctx, key, errorRate, capacity, expansion)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserveExpansion indicates an expected call of BFReserveExpansion.
func (mr *MockUniversalClientMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion)
}

// BFReserveNonScaling mocks base method.
func (m *MockUniversalClient) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserveNonScaling", ctx, key, errorRate, capacity)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserveNonScaling indicates an expected call of BFReserveNonScaling.
func (mr *MockUniversalClientMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity)
}

// BFReserveWithArgs mocks base method.
func (m *MockUniversalClient) BFReserveWithArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFReserveWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BFReserveWithArgs indicates an expected call of BFReserveWithArgs.
func (mr *MockUniversalClientMockRecorder) BFReserveWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveWithArgs), ctx, key, options)
}

// BFScanDump mocks base method.
func (m *MockUniversalClient) BFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BFScanDump", ctx, key, iterator)
	ret0, _ := ret[0].(*redis.ScanDumpCmd)
	return ret0
}

// BFScanDump indicates an expected call of BFScanDump.
func (mr *MockUniversalClientMockRecorder) BFScanDump(ctx, key, iterator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockUniversalClient)(nil).BFScanDump), ctx, key, iterator)
}

// BLMPop mocks base method.
func (m *MockUniversalClient) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *redis.KeyValuesCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout, direction, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BLMPop", varargs...)
	ret0, _ := ret[0].(*redis.KeyValuesCmd)
	return ret0
}

// BLMPop indicates an expected call of BLMPop.
func (mr *MockUniversalClientMockRecorder) BLMPop(ctx, timeout, direction, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout, direction, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockUniversalClient)(nil).BLMPop), varargs...)
}

// BLMove mocks base method.
func (m *MockUniversalClient) BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BLMove", ctx, source, destination, srcpos, destpos, timeout)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// BLMove indicates an expected call of BLMove.
func (mr *MockUniversalClientMockRecorder) BLMove(ctx, source, destination, srcpos, destpos, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockUniversalClient)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout)
}

// BLPop mocks base method.
func (m *MockUniversalClient) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BLPop", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// BLPop indicates an expected call of BLPop.
func (mr *MockUniversalClientMockRecorder) BLPop(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockUniversalClient)(nil).BLPop), varargs...)
}

// BRPop mocks base method.
func (m *MockUniversalClient) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BRPop", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// BRPop indicates an expected call of BRPop.
func (mr *MockUniversalClientMockRecorder) BRPop(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockUniversalClient)(nil).BRPop), varargs...)
}

// BRPopLPush mocks base method.
func (m *MockUniversalClient) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BRPopLPush", ctx, source, destination, timeout)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// BRPopLPush indicates an expected call of BRPopLPush.
func (mr *MockUniversalClientMockRecorder) BRPopLPush(ctx, source, destination, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockUniversalClient)(nil).BRPopLPush), ctx, source, destination, timeout)
}

// BZMPop mocks base method.
func (m *MockUniversalClient) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout, order, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BZMPop", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd)
	return ret0
}

// BZMPop indicates an expected call of BZMPop.
func (mr *MockUniversalClientMockRecorder) BZMPop(ctx, timeout, order, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout, order, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockUniversalClient)(nil).BZMPop), varargs...)
}

// BZPopMax mocks base method.
func (m *MockUniversalClient) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BZPopMax", varargs...)
	ret0, _ := ret[0].(*redis.ZWithKeyCmd)
	return ret0
}

// BZPopMax indicates an expected call of BZPopMax.
func (mr *MockUniversalClientMockRecorder) BZPopMax(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockUniversalClient)(nil).BZPopMax), varargs...)
}

// BZPopMin mocks base method.
func (m *MockUniversalClient) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, timeout}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BZPopMin", varargs...)
	ret0, _ := ret[0].(*redis.ZWithKeyCmd)
	return ret0
}

// BZPopMin indicates an expected call of BZPopMin.
func (mr *MockUniversalClientMockRecorder) BZPopMin(ctx, timeout any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, timeout}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockUniversalClient)(nil).BZPopMin), varargs...)
}

// BgRewriteAOF mocks base method.
func (m *MockUniversalClient) BgRewriteAOF(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BgRewriteAOF", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BgRewriteAOF indicates an expected call of BgRewriteAOF.
func (mr *MockUniversalClientMockRecorder) BgRewriteAOF(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockUniversalClient)(nil).BgRewriteAOF), ctx)
}

// BgSave mocks base method.
func (m *MockUniversalClient) BgSave(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BgSave", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// BgSave indicates an expected call of BgSave.
func (mr *MockUniversalClientMockRecorder) BgSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockUniversalClient)(nil).BgSave), ctx)
}

// BitCount mocks base method.
func (m *MockUniversalClient) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BitCount", ctx, key, bitCount)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitCount indicates an expected call of BitCount.
func (mr *MockUniversalClientMockRecorder) BitCount(ctx, key, bitCount any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockUniversalClient)(nil).BitCount), ctx, key, bitCount)
}

// BitField mocks base method.
func (m *MockUniversalClient) BitField(ctx context.Context, key string, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitField", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// BitField indicates an expected call of BitField.
func (mr *MockUniversalClientMockRecorder) BitField(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockUniversalClient)(nil).BitField), varargs...)
}

// BitFieldRO mocks base method.
func (m *MockUniversalClient) BitFieldRO(ctx context.Context, key string, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitFieldRO", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// BitFieldRO indicates an expected call of BitFieldRO.
func (mr *MockUniversalClientMockRecorder) BitFieldRO(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitFieldRO", reflect.TypeOf((*MockUniversalClient)(nil).BitFieldRO), varargs...)
}

// BitOpAnd mocks base method.
func (m *MockUniversalClient) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpAnd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpAnd indicates an expected call of BitOpAnd.
func (mr *MockUniversalClientMockRecorder) BitOpAnd(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockUniversalClient)(nil).BitOpAnd), varargs...)
}

// BitOpAndOr mocks base method.
func (m *MockUniversalClient) BitOpAndOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpAndOr", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpAndOr indicates an expected call of BitOpAndOr.
func (mr *MockUniversalClientMockRecorder) BitOpAndOr(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAndOr", reflect.TypeOf((*MockUniversalClient)(nil).BitOpAndOr), varargs...)
}

// BitOpDiff mocks base method.
func (m *MockUniversalClient) BitOpDiff(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpDiff", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpDiff indicates an expected call of BitOpDiff.
func (mr *MockUniversalClientMockRecorder) BitOpDiff(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpDiff", reflect.TypeOf((*MockUniversalClient)(nil).BitOpDiff), varargs...)
}

// BitOpDiff1 mocks base method.
func (m *MockUniversalClient) BitOpDiff1(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpDiff1", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpDiff1 indicates an expected call of BitOpDiff1.
func (mr *MockUniversalClientMockRecorder) BitOpDiff1(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpDiff1", reflect.TypeOf((*MockUniversalClient)(nil).BitOpDiff1), varargs...)
}

// BitOpNot mocks base method.
func (m *MockUniversalClient) BitOpNot(ctx context.Context, destKey, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BitOpNot", ctx, destKey, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpNot indicates an expected call of BitOpNot.
func (mr *MockUniversalClientMockRecorder) BitOpNot(ctx, destKey, key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockUniversalClient)(nil).BitOpNot), ctx, destKey, key)
}

// BitOpOne mocks base method.
func (m *MockUniversalClient) BitOpOne(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpOne", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpOne indicates an expected call of BitOpOne.
func (mr *MockUniversalClientMockRecorder) BitOpOne(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOne", reflect.TypeOf((*MockUniversalClient)(nil).BitOpOne), varargs...)
}

// BitOpOr mocks base method.
func (m *MockUniversalClient) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpOr", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpOr indicates an expected call of BitOpOr.
func (mr *MockUniversalClientMockRecorder) BitOpOr(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockUniversalClient)(nil).BitOpOr), varargs...)
}

// BitOpXor mocks base method.
func (m *MockUniversalClient) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitOpXor", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitOpXor indicates an expected call of BitOpXor.
func (mr *MockUniversalClientMockRecorder) BitOpXor(ctx, destKey any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockUniversalClient)(nil).BitOpXor), varargs...)
}

// BitPos mocks base method.
func (m *MockUniversalClient) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, bit}
	for _, a := range pos {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BitPos", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitPos indicates an expected call of BitPos.
func (mr *MockUniversalClientMockRecorder) BitPos(ctx, key, bit any, pos ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, bit}, pos...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockUniversalClient)(nil).BitPos), varargs...)
}

// BitPosSpan mocks base method.
func (m *MockUniversalClient) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BitPosSpan", ctx, key, bit, start, end, span)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// BitPosSpan indicates an expected call of BitPosSpan.
func (mr *MockUniversalClientMockRecorder) BitPosSpan(ctx, key, bit, start, end, span any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockUniversalClient)(nil).BitPosSpan), ctx, key, bit, start, end, span)
}

// CFAdd mocks base method.
func (m *MockUniversalClient) CFAdd(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFAdd", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFAdd indicates an expected call of CFAdd.
func (mr *MockUniversalClientMockRecorder) CFAdd(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockUniversalClient)(nil).CFAdd), ctx, key, element)
}

// CFAddNX mocks base method.
func (m *MockUniversalClient) CFAddNX(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFAddNX", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFAddNX indicates an expected call of CFAddNX.
func (mr *MockUniversalClientMockRecorder) CFAddNX(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockUniversalClient)(nil).CFAddNX), ctx, key, element)
}

// CFCount mocks base method.
func (m *MockUniversalClient) CFCount(ctx context.Context, key string, element any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFCount", ctx, key, element)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// CFCount indicates an expected call of CFCount.
func (mr *MockUniversalClientMockRecorder) CFCount(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockUniversalClient)(nil).CFCount), ctx, key, element)
}

// CFDel mocks base method.
func (m *MockUniversalClient) CFDel(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFDel", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFDel indicates an expected call of CFDel.
func (mr *MockUniversalClientMockRecorder) CFDel(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockUniversalClient)(nil).CFDel), ctx, key, element)
}

// CFExists mocks base method.
func (m *MockUniversalClient) CFExists(ctx context.Context, key string, element any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFExists", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// CFExists indicates an expected call of CFExists.
func (mr *MockUniversalClientMockRecorder) CFExists(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockUniversalClient)(nil).CFExists), ctx, key, element)
}

// CFInfo mocks base method.
func (m *MockUniversalClient) CFInfo(ctx context.Context, key string) *redis.CFInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFInfo", ctx, key)
	ret0, _ := ret[0].(*redis.CFInfoCmd)
	return ret0
}

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

// CFInsert mocks base method.
func (m *MockUniversalClient) CFInsert(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CFInsert", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// CFInsert indicates an expected call of CFInsert.
func (mr *MockUniversalClientMockRecorder) CFInsert(ctx, key, options any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockUniversalClient)(nil).CFInsert), varargs...)
}

// CFInsertNX mocks base method.
func (m *MockUniversalClient) CFInsertNX(ctx context.Context, key string, options *redis.CFInsertOptions, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CFInsertNX", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// CFInsertNX indicates an expected call of CFInsertNX.
func (mr *MockUniversalClientMockRecorder) CFInsertNX(ctx, key, options any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockUniversalClient)(nil).CFInsertNX), varargs...)
}

// CFLoadChunk mocks base method.
func (m *MockUniversalClient) CFLoadChunk(ctx context.Context, key string, iterator int64, data any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFLoadChunk", ctx, key, iterator, data)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFLoadChunk indicates an expected call of CFLoadChunk.
func (mr *MockUniversalClientMockRecorder) CFLoadChunk(ctx, key, iterator, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockUniversalClient)(nil).CFLoadChunk), ctx, key, iterator, data)
}

// CFMExists mocks base method.
func (m *MockUniversalClient) CFMExists(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CFMExists", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// CFMExists indicates an expected call of CFMExists.
func (mr *MockUniversalClientMockRecorder) CFMExists(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockUniversalClient)(nil).CFMExists), varargs...)
}

// CFReserve mocks base method.
func (m *MockUniversalClient) CFReserve(ctx context.Context, key string, capacity int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserve", ctx, key, capacity)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserve indicates an expected call of CFReserve.
func (mr *MockUniversalClientMockRecorder) CFReserve(ctx, key, capacity any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockUniversalClient)(nil).CFReserve), ctx, key, capacity)
}

// CFReserveBucketSize mocks base method.
func (m *MockUniversalClient) CFReserveBucketSize(ctx context.Context, key string, capacity, bucketsize int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveBucketSize", ctx, key, capacity, bucketsize)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveBucketSize indicates an expected call of CFReserveBucketSize.
func (mr *MockUniversalClientMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize)
}

// CFReserveExpansion mocks base method.
func (m *MockUniversalClient) CFReserveExpansion(ctx context.Context, key string, capacity, expansion int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveExpansion", ctx, key, capacity, expansion)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveExpansion indicates an expected call of CFReserveExpansion.
func (mr *MockUniversalClientMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveExpansion), ctx, key, capacity, expansion)
}

// CFReserveMaxIterations mocks base method.
func (m *MockUniversalClient) CFReserveMaxIterations(ctx context.Context, key string, capacity, maxiterations int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveMaxIterations", ctx, key, capacity, maxiterations)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations.
func (mr *MockUniversalClientMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations)
}

// CFReserveWithArgs mocks base method.
func (m *MockUniversalClient) CFReserveWithArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFReserveWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CFReserveWithArgs indicates an expected call of CFReserveWithArgs.
func (mr *MockUniversalClientMockRecorder) CFReserveWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveWithArgs), ctx, key, options)
}

// CFScanDump mocks base method.
func (m *MockUniversalClient) CFScanDump(ctx context.Context, key string, iterator int64) *redis.ScanDumpCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CFScanDump", ctx, key, iterator)
	ret0, _ := ret[0].(*redis.ScanDumpCmd)
	return ret0
}

// CFScanDump indicates an expected call of CFScanDump.
func (mr *MockUniversalClientMockRecorder) CFScanDump(ctx, key, iterator any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockUniversalClient)(nil).CFScanDump), ctx, key, iterator)
}

// CMSIncrBy mocks base method.
func (m *MockUniversalClient) CMSIncrBy(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CMSIncrBy", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// CMSIncrBy indicates an expected call of CMSIncrBy.
func (mr *MockUniversalClientMockRecorder) CMSIncrBy(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).CMSIncrBy), varargs...)
}

// CMSInfo mocks base method.
func (m *MockUniversalClient) CMSInfo(ctx context.Context, key string) *redis.CMSInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSInfo", ctx, key)
	ret0, _ := ret[0].(*redis.CMSInfoCmd)
	return ret0
}

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

// CMSInitByDim mocks base method.
func (m *MockUniversalClient) CMSInitByDim(ctx context.Context, key string, width, height int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSInitByDim", ctx, key, width, height)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSInitByDim indicates an expected call of CMSInitByDim.
func (mr *MockUniversalClientMockRecorder) CMSInitByDim(ctx, key, width, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockUniversalClient)(nil).CMSInitByDim), ctx, key, width, height)
}

// CMSInitByProb mocks base method.
func (m *MockUniversalClient) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSInitByProb", ctx, key, errorRate, probability)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSInitByProb indicates an expected call of CMSInitByProb.
func (mr *MockUniversalClientMockRecorder) CMSInitByProb(ctx, key, errorRate, probability any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockUniversalClient)(nil).CMSInitByProb), ctx, key, errorRate, probability)
}

// CMSMerge mocks base method.
func (m *MockUniversalClient) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey}
	for _, a := range sourceKeys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CMSMerge", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSMerge indicates an expected call of CMSMerge.
func (mr *MockUniversalClientMockRecorder) CMSMerge(ctx, destKey any, sourceKeys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey}, sourceKeys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockUniversalClient)(nil).CMSMerge), varargs...)
}

// CMSMergeWithWeight mocks base method.
func (m *MockUniversalClient) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CMSMergeWithWeight", ctx, destKey, sourceKeys)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight.
func (mr *MockUniversalClientMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockUniversalClient)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys)
}

// CMSQuery mocks base method.
func (m *MockUniversalClient) CMSQuery(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CMSQuery", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// CMSQuery indicates an expected call of CMSQuery.
func (mr *MockUniversalClientMockRecorder) CMSQuery(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockUniversalClient)(nil).CMSQuery), varargs...)
}

// ClientGetName mocks base method.
func (m *MockUniversalClient) ClientGetName(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientGetName", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClientGetName indicates an expected call of ClientGetName.
func (mr *MockUniversalClientMockRecorder) ClientGetName(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockUniversalClient)(nil).ClientGetName), ctx)
}

// ClientID mocks base method.
func (m *MockUniversalClient) ClientID(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientID", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientID indicates an expected call of ClientID.
func (mr *MockUniversalClientMockRecorder) ClientID(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockUniversalClient)(nil).ClientID), ctx)
}

// ClientInfo mocks base method.
func (m *MockUniversalClient) ClientInfo(ctx context.Context) *redis.ClientInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientInfo", ctx)
	ret0, _ := ret[0].(*redis.ClientInfoCmd)
	return ret0
}

// ClientInfo indicates an expected call of ClientInfo.
func (mr *MockUniversalClientMockRecorder) ClientInfo(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockUniversalClient)(nil).ClientInfo), ctx)
}

// ClientKill mocks base method.
func (m *MockUniversalClient) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientKill", ctx, ipPort)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClientKill indicates an expected call of ClientKill.
func (mr *MockUniversalClientMockRecorder) ClientKill(ctx, ipPort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockUniversalClient)(nil).ClientKill), ctx, ipPort)
}

// ClientKillByFilter mocks base method.
func (m *MockUniversalClient) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientKillByFilter indicates an expected call of ClientKillByFilter.
func (mr *MockUniversalClientMockRecorder) ClientKillByFilter(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockUniversalClient)(nil).ClientKillByFilter), varargs...)
}

// ClientList mocks base method.
func (m *MockUniversalClient) ClientList(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientList", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClientList indicates an expected call of ClientList.
func (mr *MockUniversalClientMockRecorder) ClientList(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockUniversalClient)(nil).ClientList), ctx)
}

// ClientPause mocks base method.
func (m *MockUniversalClient) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientPause", ctx, dur)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// ClientPause indicates an expected call of ClientPause.
func (mr *MockUniversalClientMockRecorder) ClientPause(ctx, dur any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockUniversalClient)(nil).ClientPause), ctx, dur)
}

// ClientUnblock mocks base method.
func (m *MockUniversalClient) ClientUnblock(ctx context.Context, id int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientUnblock", ctx, id)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientUnblock indicates an expected call of ClientUnblock.
func (mr *MockUniversalClientMockRecorder) ClientUnblock(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnblock), ctx, id)
}

// ClientUnblockWithError mocks base method.
func (m *MockUniversalClient) ClientUnblockWithError(ctx context.Context, id int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientUnblockWithError", ctx, id)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClientUnblockWithError indicates an expected call of ClientUnblockWithError.
func (mr *MockUniversalClientMockRecorder) ClientUnblockWithError(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnblockWithError), ctx, id)
}

// ClientUnpause mocks base method.
func (m *MockUniversalClient) ClientUnpause(ctx context.Context) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClientUnpause", ctx)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// ClientUnpause indicates an expected call of ClientUnpause.
func (mr *MockUniversalClientMockRecorder) ClientUnpause(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnpause), ctx)
}

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

// Close indicates an expected call of Close.
func (mr *MockUniversalClientMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockUniversalClient)(nil).Close))
}

// ClusterAddSlots mocks base method.
func (m *MockUniversalClient) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range slots {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterAddSlots indicates an expected call of ClusterAddSlots.
func (mr *MockUniversalClientMockRecorder) ClusterAddSlots(ctx any, slots ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, slots...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterAddSlots), varargs...)
}

// ClusterAddSlotsRange mocks base method.
func (m *MockUniversalClient) ClusterAddSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterAddSlotsRange", ctx, min, max)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange.
func (mr *MockUniversalClientMockRecorder) ClusterAddSlotsRange(ctx, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockUniversalClient)(nil).ClusterAddSlotsRange), ctx, min, max)
}

// ClusterCountFailureReports mocks base method.
func (m *MockUniversalClient) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterCountFailureReports", ctx, nodeID)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports.
func (mr *MockUniversalClientMockRecorder) ClusterCountFailureReports(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockUniversalClient)(nil).ClusterCountFailureReports), ctx, nodeID)
}

// ClusterCountKeysInSlot mocks base method.
func (m *MockUniversalClient) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", ctx, slot)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot.
func (mr *MockUniversalClientMockRecorder) ClusterCountKeysInSlot(ctx, slot any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterCountKeysInSlot), ctx, slot)
}

// ClusterDelSlots mocks base method.
func (m *MockUniversalClient) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range slots {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterDelSlots indicates an expected call of ClusterDelSlots.
func (mr *MockUniversalClientMockRecorder) ClusterDelSlots(ctx any, slots ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, slots...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterDelSlots), varargs...)
}

// ClusterDelSlotsRange mocks base method.
func (m *MockUniversalClient) ClusterDelSlotsRange(ctx context.Context, min, max int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterDelSlotsRange", ctx, min, max)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange.
func (mr *MockUniversalClientMockRecorder) ClusterDelSlotsRange(ctx, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockUniversalClient)(nil).ClusterDelSlotsRange), ctx, min, max)
}

// ClusterFailover mocks base method.
func (m *MockUniversalClient) ClusterFailover(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterFailover", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterFailover indicates an expected call of ClusterFailover.
func (mr *MockUniversalClientMockRecorder) ClusterFailover(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockUniversalClient)(nil).ClusterFailover), ctx)
}

// ClusterForget mocks base method.
func (m *MockUniversalClient) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterForget", ctx, nodeID)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterForget indicates an expected call of ClusterForget.
func (mr *MockUniversalClientMockRecorder) ClusterForget(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockUniversalClient)(nil).ClusterForget), ctx, nodeID)
}

// ClusterGetKeysInSlot mocks base method.
func (m *MockUniversalClient) ClusterGetKeysInSlot(ctx context.Context, slot, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", ctx, slot, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot.
func (mr *MockUniversalClientMockRecorder) ClusterGetKeysInSlot(ctx, slot, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterGetKeysInSlot), ctx, slot, count)
}

// ClusterInfo mocks base method.
func (m *MockUniversalClient) ClusterInfo(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterInfo", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterInfo indicates an expected call of ClusterInfo.
func (mr *MockUniversalClientMockRecorder) ClusterInfo(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockUniversalClient)(nil).ClusterInfo), ctx)
}

// ClusterKeySlot mocks base method.
func (m *MockUniversalClient) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterKeySlot", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// ClusterLinks mocks base method.
func (m *MockUniversalClient) ClusterLinks(ctx context.Context) *redis.ClusterLinksCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterLinks", ctx)
	ret0, _ := ret[0].(*redis.ClusterLinksCmd)
	return ret0
}

// ClusterLinks indicates an expected call of ClusterLinks.
func (mr *MockUniversalClientMockRecorder) ClusterLinks(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockUniversalClient)(nil).ClusterLinks), ctx)
}

// ClusterMeet mocks base method.
func (m *MockUniversalClient) ClusterMeet(ctx context.Context, host, port string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterMeet", ctx, host, port)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterMeet indicates an expected call of ClusterMeet.
func (mr *MockUniversalClientMockRecorder) ClusterMeet(ctx, host, port any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMeet), ctx, host, port)
}

// ClusterMyID mocks base method.
func (m *MockUniversalClient) ClusterMyID(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterMyID", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterMyID indicates an expected call of ClusterMyID.
func (mr *MockUniversalClientMockRecorder) ClusterMyID(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyID", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMyID), ctx)
}

// ClusterMyShardID mocks base method.
func (m *MockUniversalClient) ClusterMyShardID(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterMyShardID", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterMyShardID indicates an expected call of ClusterMyShardID.
func (mr *MockUniversalClientMockRecorder) ClusterMyShardID(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMyShardID), ctx)
}

// ClusterNodes mocks base method.
func (m *MockUniversalClient) ClusterNodes(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterNodes", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ClusterNodes indicates an expected call of ClusterNodes.
func (mr *MockUniversalClientMockRecorder) ClusterNodes(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockUniversalClient)(nil).ClusterNodes), ctx)
}

// ClusterReplicate mocks base method.
func (m *MockUniversalClient) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterReplicate", ctx, nodeID)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterReplicate indicates an expected call of ClusterReplicate.
func (mr *MockUniversalClientMockRecorder) ClusterReplicate(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockUniversalClient)(nil).ClusterReplicate), ctx, nodeID)
}

// ClusterResetHard mocks base method.
func (m *MockUniversalClient) ClusterResetHard(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterResetHard", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterResetHard indicates an expected call of ClusterResetHard.
func (mr *MockUniversalClientMockRecorder) ClusterResetHard(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockUniversalClient)(nil).ClusterResetHard), ctx)
}

// ClusterResetSoft mocks base method.
func (m *MockUniversalClient) ClusterResetSoft(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterResetSoft", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterResetSoft indicates an expected call of ClusterResetSoft.
func (mr *MockUniversalClientMockRecorder) ClusterResetSoft(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockUniversalClient)(nil).ClusterResetSoft), ctx)
}

// ClusterSaveConfig mocks base method.
func (m *MockUniversalClient) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterSaveConfig", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ClusterSaveConfig indicates an expected call of ClusterSaveConfig.
func (mr *MockUniversalClientMockRecorder) ClusterSaveConfig(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSaveConfig), ctx)
}

// ClusterShards mocks base method.
func (m *MockUniversalClient) ClusterShards(ctx context.Context) *redis.ClusterShardsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterShards", ctx)
	ret0, _ := ret[0].(*redis.ClusterShardsCmd)
	return ret0
}

// ClusterShards indicates an expected call of ClusterShards.
func (mr *MockUniversalClientMockRecorder) ClusterShards(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockUniversalClient)(nil).ClusterShards), ctx)
}

// ClusterSlaves mocks base method.
func (m *MockUniversalClient) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterSlaves", ctx, nodeID)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ClusterSlaves indicates an expected call of ClusterSlaves.
func (mr *MockUniversalClientMockRecorder) ClusterSlaves(ctx, nodeID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSlaves), ctx, nodeID)
}

// ClusterSlots mocks base method.
func (m *MockUniversalClient) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterSlots", ctx)
	ret0, _ := ret[0].(*redis.ClusterSlotsCmd)
	return ret0
}

// ClusterSlots indicates an expected call of ClusterSlots.
func (mr *MockUniversalClientMockRecorder) ClusterSlots(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSlots), ctx)
}

// Command mocks base method.
func (m *MockUniversalClient) Command(ctx context.Context) *redis.CommandsInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Command", ctx)
	ret0, _ := ret[0].(*redis.CommandsInfoCmd)
	return ret0
}

// Command indicates an expected call of Command.
func (mr *MockUniversalClientMockRecorder) Command(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockUniversalClient)(nil).Command), ctx)
}

// CommandGetKeys mocks base method.
func (m *MockUniversalClient) CommandGetKeys(ctx context.Context, commands ...any) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range commands {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommandGetKeys", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// CommandGetKeys indicates an expected call of CommandGetKeys.
func (mr *MockUniversalClientMockRecorder) CommandGetKeys(ctx any, commands ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, commands...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockUniversalClient)(nil).CommandGetKeys), varargs...)
}

// CommandGetKeysAndFlags mocks base method.
func (m *MockUniversalClient) CommandGetKeysAndFlags(ctx context.Context, commands ...any) *redis.KeyFlagsCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range commands {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...)
	ret0, _ := ret[0].(*redis.KeyFlagsCmd)
	return ret0
}

// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags.
func (mr *MockUniversalClientMockRecorder) CommandGetKeysAndFlags(ctx any, commands ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, commands...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockUniversalClient)(nil).CommandGetKeysAndFlags), varargs...)
}

// CommandList mocks base method.
func (m *MockUniversalClient) CommandList(ctx context.Context, filter *redis.FilterBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CommandList", ctx, filter)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// CommandList indicates an expected call of CommandList.
func (mr *MockUniversalClientMockRecorder) CommandList(ctx, filter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockUniversalClient)(nil).CommandList), ctx, filter)
}

// ConfigGet mocks base method.
func (m *MockUniversalClient) ConfigGet(ctx context.Context, parameter string) *redis.MapStringStringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigGet", ctx, parameter)
	ret0, _ := ret[0].(*redis.MapStringStringCmd)
	return ret0
}

// ConfigGet indicates an expected call of ConfigGet.
func (mr *MockUniversalClientMockRecorder) ConfigGet(ctx, parameter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).ConfigGet), ctx, parameter)
}

// ConfigResetStat mocks base method.
func (m *MockUniversalClient) ConfigResetStat(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigResetStat", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ConfigResetStat indicates an expected call of ConfigResetStat.
func (mr *MockUniversalClientMockRecorder) ConfigResetStat(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockUniversalClient)(nil).ConfigResetStat), ctx)
}

// ConfigRewrite mocks base method.
func (m *MockUniversalClient) ConfigRewrite(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigRewrite", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ConfigRewrite indicates an expected call of ConfigRewrite.
func (mr *MockUniversalClientMockRecorder) ConfigRewrite(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockUniversalClient)(nil).ConfigRewrite), ctx)
}

// ConfigSet mocks base method.
func (m *MockUniversalClient) ConfigSet(ctx context.Context, parameter, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConfigSet", ctx, parameter, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ConfigSet indicates an expected call of ConfigSet.
func (mr *MockUniversalClientMockRecorder) ConfigSet(ctx, parameter, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).ConfigSet), ctx, parameter, value)
}

// Copy mocks base method.
func (m *MockUniversalClient) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Copy", ctx, sourceKey, destKey, db, replace)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Copy indicates an expected call of Copy.
func (mr *MockUniversalClientMockRecorder) Copy(ctx, sourceKey, destKey, db, replace any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockUniversalClient)(nil).Copy), ctx, sourceKey, destKey, db, replace)
}

// DBSize mocks base method.
func (m *MockUniversalClient) DBSize(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DBSize", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// DBSize indicates an expected call of DBSize.
func (mr *MockUniversalClientMockRecorder) DBSize(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockUniversalClient)(nil).DBSize), ctx)
}

// DebugObject mocks base method.
func (m *MockUniversalClient) DebugObject(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DebugObject", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// Decr mocks base method.
func (m *MockUniversalClient) Decr(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Decr", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// DecrBy mocks base method.
func (m *MockUniversalClient) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecrBy", ctx, key, decrement)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// DecrBy indicates an expected call of DecrBy.
func (mr *MockUniversalClientMockRecorder) DecrBy(ctx, key, decrement any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockUniversalClient)(nil).DecrBy), ctx, key, decrement)
}

// Del mocks base method.
func (m *MockUniversalClient) Del(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Del", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Del indicates an expected call of Del.
func (mr *MockUniversalClientMockRecorder) Del(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockUniversalClient)(nil).Del), varargs...)
}

// Do mocks base method.
func (m *MockUniversalClient) Do(ctx context.Context, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Do", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// Do indicates an expected call of Do.
func (mr *MockUniversalClientMockRecorder) Do(ctx any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockUniversalClient)(nil).Do), varargs...)
}

// Dump mocks base method.
func (m *MockUniversalClient) Dump(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Dump", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// Echo mocks base method.
func (m *MockUniversalClient) Echo(ctx context.Context, message any) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Echo", ctx, message)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// Echo indicates an expected call of Echo.
func (mr *MockUniversalClientMockRecorder) Echo(ctx, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockUniversalClient)(nil).Echo), ctx, message)
}

// Eval mocks base method.
func (m *MockUniversalClient) Eval(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, script, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Eval", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// Eval indicates an expected call of Eval.
func (mr *MockUniversalClientMockRecorder) Eval(ctx, script, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, script, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockUniversalClient)(nil).Eval), varargs...)
}

// EvalRO mocks base method.
func (m *MockUniversalClient) EvalRO(ctx context.Context, script string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, script, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvalRO", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// EvalRO indicates an expected call of EvalRO.
func (mr *MockUniversalClientMockRecorder) EvalRO(ctx, script, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, script, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockUniversalClient)(nil).EvalRO), varargs...)
}

// EvalSha mocks base method.
func (m *MockUniversalClient) EvalSha(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, sha1, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvalSha", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// EvalSha indicates an expected call of EvalSha.
func (mr *MockUniversalClientMockRecorder) EvalSha(ctx, sha1, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, sha1, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockUniversalClient)(nil).EvalSha), varargs...)
}

// EvalShaRO mocks base method.
func (m *MockUniversalClient) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, sha1, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EvalShaRO", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// EvalShaRO indicates an expected call of EvalShaRO.
func (mr *MockUniversalClientMockRecorder) EvalShaRO(ctx, sha1, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, sha1, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockUniversalClient)(nil).EvalShaRO), varargs...)
}

// Exists mocks base method.
func (m *MockUniversalClient) Exists(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Exists", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Exists indicates an expected call of Exists.
func (mr *MockUniversalClientMockRecorder) Exists(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockUniversalClient)(nil).Exists), varargs...)
}

// Expire mocks base method.
func (m *MockUniversalClient) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Expire", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireAt mocks base method.
func (m *MockUniversalClient) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireAt", ctx, key, tm)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// ExpireAt indicates an expected call of ExpireAt.
func (mr *MockUniversalClientMockRecorder) ExpireAt(ctx, key, tm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).ExpireAt), ctx, key, tm)
}

// ExpireGT mocks base method.
func (m *MockUniversalClient) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireGT", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireLT mocks base method.
func (m *MockUniversalClient) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireLT", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireNX mocks base method.
func (m *MockUniversalClient) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireNX", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// ExpireTime mocks base method.
func (m *MockUniversalClient) ExpireTime(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireTime", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// ExpireXX mocks base method.
func (m *MockUniversalClient) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExpireXX", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// FCall mocks base method.
func (m *MockUniversalClient) FCall(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, function, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FCall", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// FCall indicates an expected call of FCall.
func (mr *MockUniversalClientMockRecorder) FCall(ctx, function, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, function, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockUniversalClient)(nil).FCall), varargs...)
}

// FCallRO mocks base method.
func (m *MockUniversalClient) FCallRO(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, function, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FCallRO", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// FCallRO indicates an expected call of FCallRO.
func (mr *MockUniversalClientMockRecorder) FCallRO(ctx, function, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, function, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockUniversalClient)(nil).FCallRO), varargs...)
}

// FCallRo mocks base method.
func (m *MockUniversalClient) FCallRo(ctx context.Context, function string, keys []string, args ...any) *redis.Cmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, function, keys}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FCallRo", varargs...)
	ret0, _ := ret[0].(*redis.Cmd)
	return ret0
}

// FCallRo indicates an expected call of FCallRo.
func (mr *MockUniversalClientMockRecorder) FCallRo(ctx, function, keys any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, function, keys}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockUniversalClient)(nil).FCallRo), varargs...)
}

// FTAggregate mocks base method.
func (m *MockUniversalClient) FTAggregate(ctx context.Context, index, query string) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAggregate", ctx, index, query)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

// FTAggregate indicates an expected call of FTAggregate.
func (mr *MockUniversalClientMockRecorder) FTAggregate(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregate", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregate), ctx, index, query)
}

// FTAggregateWithArgs mocks base method.
func (m *MockUniversalClient) FTAggregateWithArgs(ctx context.Context, index, query string, options *redis.FTAggregateOptions) *redis.AggregateCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAggregateWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.AggregateCmd)
	return ret0
}

// FTAggregateWithArgs indicates an expected call of FTAggregateWithArgs.
func (mr *MockUniversalClientMockRecorder) FTAggregateWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAggregateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTAggregateWithArgs), ctx, index, query, options)
}

// FTAliasAdd mocks base method.
func (m *MockUniversalClient) FTAliasAdd(ctx context.Context, index, alias string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAliasAdd", ctx, index, alias)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAliasAdd indicates an expected call of FTAliasAdd.
func (mr *MockUniversalClientMockRecorder) FTAliasAdd(ctx, index, alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasAdd), ctx, index, alias)
}

// FTAliasDel mocks base method.
func (m *MockUniversalClient) FTAliasDel(ctx context.Context, alias string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAliasDel", ctx, alias)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAliasDel indicates an expected call of FTAliasDel.
func (mr *MockUniversalClientMockRecorder) FTAliasDel(ctx, alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasDel", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasDel), ctx, alias)
}

// FTAliasUpdate mocks base method.
func (m *MockUniversalClient) FTAliasUpdate(ctx context.Context, index, alias string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAliasUpdate", ctx, index, alias)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAliasUpdate indicates an expected call of FTAliasUpdate.
func (mr *MockUniversalClientMockRecorder) FTAliasUpdate(ctx, index, alias any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAliasUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTAliasUpdate), ctx, index, alias)
}

// FTAlter mocks base method.
func (m *MockUniversalClient) FTAlter(ctx context.Context, index string, skipInitialScan bool, definition []any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTAlter", ctx, index, skipInitialScan, definition)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTAlter indicates an expected call of FTAlter.
func (mr *MockUniversalClientMockRecorder) FTAlter(ctx, index, skipInitialScan, definition any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTAlter", reflect.TypeOf((*MockUniversalClient)(nil).FTAlter), ctx, index, skipInitialScan, definition)
}

// FTConfigGet mocks base method.
func (m *MockUniversalClient) FTConfigGet(ctx context.Context, option string) *redis.MapMapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTConfigGet", ctx, option)
	ret0, _ := ret[0].(*redis.MapMapStringInterfaceCmd)
	return ret0
}

// FTConfigGet indicates an expected call of FTConfigGet.
func (mr *MockUniversalClientMockRecorder) FTConfigGet(ctx, option any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigGet), ctx, option)
}

// FTConfigSet mocks base method.
func (m *MockUniversalClient) FTConfigSet(ctx context.Context, option string, value any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTConfigSet", ctx, option, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTConfigSet indicates an expected call of FTConfigSet.
func (mr *MockUniversalClientMockRecorder) FTConfigSet(ctx, option, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).FTConfigSet), ctx, option, value)
}

// FTCreate mocks base method.
func (m *MockUniversalClient) FTCreate(ctx context.Context, index string, options *redis.FTCreateOptions, schema ...*redis.FieldSchema) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, index, options}
	for _, a := range schema {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FTCreate", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTCreate indicates an expected call of FTCreate.
func (mr *MockUniversalClientMockRecorder) FTCreate(ctx, index, options any, schema ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, index, options}, schema...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCreate", reflect.TypeOf((*MockUniversalClient)(nil).FTCreate), varargs...)
}

// FTCursorDel mocks base method.
func (m *MockUniversalClient) FTCursorDel(ctx context.Context, index string, cursorId int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTCursorDel", ctx, index, cursorId)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTCursorDel indicates an expected call of FTCursorDel.
func (mr *MockUniversalClientMockRecorder) FTCursorDel(ctx, index, cursorId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorDel", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorDel), ctx, index, cursorId)
}

// FTCursorRead mocks base method.
func (m *MockUniversalClient) FTCursorRead(ctx context.Context, index string, cursorId, count int) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTCursorRead", ctx, index, cursorId, count)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

// FTCursorRead indicates an expected call of FTCursorRead.
func (mr *MockUniversalClientMockRecorder) FTCursorRead(ctx, index, cursorId, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTCursorRead", reflect.TypeOf((*MockUniversalClient)(nil).FTCursorRead), ctx, index, cursorId, count)
}

// FTDictAdd mocks base method.
func (m *MockUniversalClient) FTDictAdd(ctx context.Context, dict string, term ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dict}
	for _, a := range term {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FTDictAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// FTDictAdd indicates an expected call of FTDictAdd.
func (mr *MockUniversalClientMockRecorder) FTDictAdd(ctx, dict any, term ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, dict}, term...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictAdd", reflect.TypeOf((*MockUniversalClient)(nil).FTDictAdd), varargs...)
}

// FTDictDel mocks base method.
func (m *MockUniversalClient) FTDictDel(ctx context.Context, dict string, term ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dict}
	for _, a := range term {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FTDictDel", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// FTDictDel indicates an expected call of FTDictDel.
func (mr *MockUniversalClientMockRecorder) FTDictDel(ctx, dict any, term ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, dict}, term...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDel", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDel), varargs...)
}

// FTDictDump mocks base method.
func (m *MockUniversalClient) FTDictDump(ctx context.Context, dict string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTDictDump", ctx, dict)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// FTDictDump indicates an expected call of FTDictDump.
func (mr *MockUniversalClientMockRecorder) FTDictDump(ctx, dict any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDictDump", reflect.TypeOf((*MockUniversalClient)(nil).FTDictDump), ctx, dict)
}

// FTDropIndex mocks base method.
func (m *MockUniversalClient) FTDropIndex(ctx context.Context, index string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTDropIndex", ctx, index)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTDropIndex indicates an expected call of FTDropIndex.
func (mr *MockUniversalClientMockRecorder) FTDropIndex(ctx, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndex", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndex), ctx, index)
}

// FTDropIndexWithArgs mocks base method.
func (m *MockUniversalClient) FTDropIndexWithArgs(ctx context.Context, index string, options *redis.FTDropIndexOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTDropIndexWithArgs", ctx, index, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTDropIndexWithArgs indicates an expected call of FTDropIndexWithArgs.
func (mr *MockUniversalClientMockRecorder) FTDropIndexWithArgs(ctx, index, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTDropIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTDropIndexWithArgs), ctx, index, options)
}

// FTExplain mocks base method.
func (m *MockUniversalClient) FTExplain(ctx context.Context, index, query string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTExplain", ctx, index, query)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FTExplain indicates an expected call of FTExplain.
func (mr *MockUniversalClientMockRecorder) FTExplain(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplain", reflect.TypeOf((*MockUniversalClient)(nil).FTExplain), ctx, index, query)
}

// FTExplainWithArgs mocks base method.
func (m *MockUniversalClient) FTExplainWithArgs(ctx context.Context, index, query string, options *redis.FTExplainOptions) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTExplainWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FTExplainWithArgs indicates an expected call of FTExplainWithArgs.
func (mr *MockUniversalClientMockRecorder) FTExplainWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTExplainWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTExplainWithArgs), ctx, index, query, options)
}

// FTInfo mocks base method.
func (m *MockUniversalClient) FTInfo(ctx context.Context, index string) *redis.FTInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTInfo", ctx, index)
	ret0, _ := ret[0].(*redis.FTInfoCmd)
	return ret0
}

// FTInfo indicates an expected call of FTInfo.
func (mr *MockUniversalClientMockRecorder) FTInfo(ctx, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTInfo", reflect.TypeOf((*MockUniversalClient)(nil).FTInfo), ctx, index)
}

// FTSearch mocks base method.
func (m *MockUniversalClient) FTSearch(ctx context.Context, index, query string) *redis.FTSearchCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSearch", ctx, index, query)
	ret0, _ := ret[0].(*redis.FTSearchCmd)
	return ret0
}

// FTSearch indicates an expected call of FTSearch.
func (mr *MockUniversalClientMockRecorder) FTSearch(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearch", reflect.TypeOf((*MockUniversalClient)(nil).FTSearch), ctx, index, query)
}

// FTSearchWithArgs mocks base method.
func (m *MockUniversalClient) FTSearchWithArgs(ctx context.Context, index, query string, options *redis.FTSearchOptions) *redis.FTSearchCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSearchWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.FTSearchCmd)
	return ret0
}

// FTSearchWithArgs indicates an expected call of FTSearchWithArgs.
func (mr *MockUniversalClientMockRecorder) FTSearchWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSearchWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSearchWithArgs), ctx, index, query, options)
}

// FTSpellCheck mocks base method.
func (m *MockUniversalClient) FTSpellCheck(ctx context.Context, index, query string) *redis.FTSpellCheckCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSpellCheck", ctx, index, query)
	ret0, _ := ret[0].(*redis.FTSpellCheckCmd)
	return ret0
}

// FTSpellCheck indicates an expected call of FTSpellCheck.
func (mr *MockUniversalClientMockRecorder) FTSpellCheck(ctx, index, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheck", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheck), ctx, index, query)
}

// FTSpellCheckWithArgs mocks base method.
func (m *MockUniversalClient) FTSpellCheckWithArgs(ctx context.Context, index, query string, options *redis.FTSpellCheckOptions) *redis.FTSpellCheckCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSpellCheckWithArgs", ctx, index, query, options)
	ret0, _ := ret[0].(*redis.FTSpellCheckCmd)
	return ret0
}

// FTSpellCheckWithArgs indicates an expected call of FTSpellCheckWithArgs.
func (mr *MockUniversalClientMockRecorder) FTSpellCheckWithArgs(ctx, index, query, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSpellCheckWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSpellCheckWithArgs), ctx, index, query, options)
}

// FTSynDump mocks base method.
func (m *MockUniversalClient) FTSynDump(ctx context.Context, index string) *redis.FTSynDumpCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSynDump", ctx, index)
	ret0, _ := ret[0].(*redis.FTSynDumpCmd)
	return ret0
}

// FTSynDump indicates an expected call of FTSynDump.
func (mr *MockUniversalClientMockRecorder) FTSynDump(ctx, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynDump", reflect.TypeOf((*MockUniversalClient)(nil).FTSynDump), ctx, index)
}

// FTSynUpdate mocks base method.
func (m *MockUniversalClient) FTSynUpdate(ctx context.Context, index string, synGroupId any, terms []any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSynUpdate", ctx, index, synGroupId, terms)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTSynUpdate indicates an expected call of FTSynUpdate.
func (mr *MockUniversalClientMockRecorder) FTSynUpdate(ctx, index, synGroupId, terms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdate", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdate), ctx, index, synGroupId, terms)
}

// FTSynUpdateWithArgs mocks base method.
func (m *MockUniversalClient) FTSynUpdateWithArgs(ctx context.Context, index string, synGroupId any, options *redis.FTSynUpdateOptions, terms []any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTSynUpdateWithArgs", ctx, index, synGroupId, options, terms)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FTSynUpdateWithArgs indicates an expected call of FTSynUpdateWithArgs.
func (mr *MockUniversalClientMockRecorder) FTSynUpdateWithArgs(ctx, index, synGroupId, options, terms any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTSynUpdateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).FTSynUpdateWithArgs), ctx, index, synGroupId, options, terms)
}

// FTTagVals mocks base method.
func (m *MockUniversalClient) FTTagVals(ctx context.Context, index, field string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FTTagVals", ctx, index, field)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// FTTagVals indicates an expected call of FTTagVals.
func (mr *MockUniversalClientMockRecorder) FTTagVals(ctx, index, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FTTagVals", reflect.TypeOf((*MockUniversalClient)(nil).FTTagVals), ctx, index, field)
}

// FT_List mocks base method.
func (m *MockUniversalClient) FT_List(ctx context.Context) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FT_List", ctx)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// FT_List indicates an expected call of FT_List.
func (mr *MockUniversalClientMockRecorder) FT_List(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FT_List", reflect.TypeOf((*MockUniversalClient)(nil).FT_List), ctx)
}

// FlushAll mocks base method.
func (m *MockUniversalClient) FlushAll(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushAll", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushAll indicates an expected call of FlushAll.
func (mr *MockUniversalClientMockRecorder) FlushAll(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockUniversalClient)(nil).FlushAll), ctx)
}

// FlushAllAsync mocks base method.
func (m *MockUniversalClient) FlushAllAsync(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushAllAsync", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushAllAsync indicates an expected call of FlushAllAsync.
func (mr *MockUniversalClientMockRecorder) FlushAllAsync(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockUniversalClient)(nil).FlushAllAsync), ctx)
}

// FlushDB mocks base method.
func (m *MockUniversalClient) FlushDB(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushDB", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushDB indicates an expected call of FlushDB.
func (mr *MockUniversalClientMockRecorder) FlushDB(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockUniversalClient)(nil).FlushDB), ctx)
}

// FlushDBAsync mocks base method.
func (m *MockUniversalClient) FlushDBAsync(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FlushDBAsync", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// FlushDBAsync indicates an expected call of FlushDBAsync.
func (mr *MockUniversalClientMockRecorder) FlushDBAsync(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockUniversalClient)(nil).FlushDBAsync), ctx)
}

// FunctionDelete mocks base method.
func (m *MockUniversalClient) FunctionDelete(ctx context.Context, libName string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionDelete", ctx, libName)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionDelete indicates an expected call of FunctionDelete.
func (mr *MockUniversalClientMockRecorder) FunctionDelete(ctx, libName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockUniversalClient)(nil).FunctionDelete), ctx, libName)
}

// FunctionDump mocks base method.
func (m *MockUniversalClient) FunctionDump(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionDump", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionDump indicates an expected call of FunctionDump.
func (mr *MockUniversalClientMockRecorder) FunctionDump(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockUniversalClient)(nil).FunctionDump), ctx)
}

// FunctionFlush mocks base method.
func (m *MockUniversalClient) FunctionFlush(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionFlush", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionFlush indicates an expected call of FunctionFlush.
func (mr *MockUniversalClientMockRecorder) FunctionFlush(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockUniversalClient)(nil).FunctionFlush), ctx)
}

// FunctionFlushAsync mocks base method.
func (m *MockUniversalClient) FunctionFlushAsync(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionFlushAsync", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionFlushAsync indicates an expected call of FunctionFlushAsync.
func (mr *MockUniversalClientMockRecorder) FunctionFlushAsync(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockUniversalClient)(nil).FunctionFlushAsync), ctx)
}

// FunctionKill mocks base method.
func (m *MockUniversalClient) FunctionKill(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionKill", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionKill indicates an expected call of FunctionKill.
func (mr *MockUniversalClientMockRecorder) FunctionKill(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockUniversalClient)(nil).FunctionKill), ctx)
}

// FunctionList mocks base method.
func (m *MockUniversalClient) FunctionList(ctx context.Context, q redis.FunctionListQuery) *redis.FunctionListCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionList", ctx, q)
	ret0, _ := ret[0].(*redis.FunctionListCmd)
	return ret0
}

// FunctionList indicates an expected call of FunctionList.
func (mr *MockUniversalClientMockRecorder) FunctionList(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockUniversalClient)(nil).FunctionList), ctx, q)
}

// FunctionLoad mocks base method.
func (m *MockUniversalClient) FunctionLoad(ctx context.Context, code string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionLoad", ctx, code)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionLoad indicates an expected call of FunctionLoad.
func (mr *MockUniversalClientMockRecorder) FunctionLoad(ctx, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockUniversalClient)(nil).FunctionLoad), ctx, code)
}

// FunctionLoadReplace mocks base method.
func (m *MockUniversalClient) FunctionLoadReplace(ctx context.Context, code string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionLoadReplace", ctx, code)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionLoadReplace indicates an expected call of FunctionLoadReplace.
func (mr *MockUniversalClientMockRecorder) FunctionLoadReplace(ctx, code any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockUniversalClient)(nil).FunctionLoadReplace), ctx, code)
}

// FunctionRestore mocks base method.
func (m *MockUniversalClient) FunctionRestore(ctx context.Context, libDump string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionRestore", ctx, libDump)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// FunctionRestore indicates an expected call of FunctionRestore.
func (mr *MockUniversalClientMockRecorder) FunctionRestore(ctx, libDump any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockUniversalClient)(nil).FunctionRestore), ctx, libDump)
}

// FunctionStats mocks base method.
func (m *MockUniversalClient) FunctionStats(ctx context.Context) *redis.FunctionStatsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FunctionStats", ctx)
	ret0, _ := ret[0].(*redis.FunctionStatsCmd)
	return ret0
}

// FunctionStats indicates an expected call of FunctionStats.
func (mr *MockUniversalClientMockRecorder) FunctionStats(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockUniversalClient)(nil).FunctionStats), ctx)
}

// GeoAdd mocks base method.
func (m *MockUniversalClient) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range geoLocation {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GeoAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoAdd indicates an expected call of GeoAdd.
func (mr *MockUniversalClientMockRecorder) GeoAdd(ctx, key any, geoLocation ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, geoLocation...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockUniversalClient)(nil).GeoAdd), varargs...)
}

// GeoDist mocks base method.
func (m *MockUniversalClient) GeoDist(ctx context.Context, key, member1, member2, unit string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoDist", ctx, key, member1, member2, unit)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// GeoDist indicates an expected call of GeoDist.
func (mr *MockUniversalClientMockRecorder) GeoDist(ctx, key, member1, member2, unit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockUniversalClient)(nil).GeoDist), ctx, key, member1, member2, unit)
}

// GeoHash mocks base method.
func (m *MockUniversalClient) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GeoHash", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// GeoHash indicates an expected call of GeoHash.
func (mr *MockUniversalClientMockRecorder) GeoHash(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockUniversalClient)(nil).GeoHash), varargs...)
}

// GeoPos mocks base method.
func (m *MockUniversalClient) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GeoPos", varargs...)
	ret0, _ := ret[0].(*redis.GeoPosCmd)
	return ret0
}

// GeoPos indicates an expected call of GeoPos.
func (mr *MockUniversalClientMockRecorder) GeoPos(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockUniversalClient)(nil).GeoPos), varargs...)
}

// GeoRadius mocks base method.
func (m *MockUniversalClient) GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadius", ctx, key, longitude, latitude, query)
	ret0, _ := ret[0].(*redis.GeoLocationCmd)
	return ret0
}

// GeoRadius indicates an expected call of GeoRadius.
func (mr *MockUniversalClientMockRecorder) GeoRadius(ctx, key, longitude, latitude, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadius), ctx, key, longitude, latitude, query)
}

// GeoRadiusByMember mocks base method.
func (m *MockUniversalClient) GeoRadiusByMember(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadiusByMember", ctx, key, member, query)
	ret0, _ := ret[0].(*redis.GeoLocationCmd)
	return ret0
}

// GeoRadiusByMember indicates an expected call of GeoRadiusByMember.
func (mr *MockUniversalClientMockRecorder) GeoRadiusByMember(ctx, key, member, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusByMember), ctx, key, member, query)
}

// GeoRadiusByMemberStore mocks base method.
func (m *MockUniversalClient) GeoRadiusByMemberStore(ctx context.Context, key, member string, query *redis.GeoRadiusQuery) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", ctx, key, member, query)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore.
func (mr *MockUniversalClientMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusByMemberStore), ctx, key, member, query)
}

// GeoRadiusStore mocks base method.
func (m *MockUniversalClient) GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoRadiusStore", ctx, key, longitude, latitude, query)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoRadiusStore indicates an expected call of GeoRadiusStore.
func (mr *MockUniversalClientMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query)
}

// GeoSearch mocks base method.
func (m *MockUniversalClient) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoSearch", ctx, key, q)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// GeoSearch indicates an expected call of GeoSearch.
func (mr *MockUniversalClientMockRecorder) GeoSearch(ctx, key, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearch), ctx, key, q)
}

// GeoSearchLocation mocks base method.
func (m *MockUniversalClient) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoSearchLocation", ctx, key, q)
	ret0, _ := ret[0].(*redis.GeoSearchLocationCmd)
	return ret0
}

// GeoSearchLocation indicates an expected call of GeoSearchLocation.
func (mr *MockUniversalClientMockRecorder) GeoSearchLocation(ctx, key, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearchLocation), ctx, key, q)
}

// GeoSearchStore mocks base method.
func (m *MockUniversalClient) GeoSearchStore(ctx context.Context, key, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeoSearchStore", ctx, key, store, q)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GeoSearchStore indicates an expected call of GeoSearchStore.
func (mr *MockUniversalClientMockRecorder) GeoSearchStore(ctx, key, store, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearchStore), ctx, key, store, q)
}

// Get mocks base method.
func (m *MockUniversalClient) Get(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// GetBit mocks base method.
func (m *MockUniversalClient) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBit", ctx, key, offset)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// GetBit indicates an expected call of GetBit.
func (mr *MockUniversalClientMockRecorder) GetBit(ctx, key, offset any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockUniversalClient)(nil).GetBit), ctx, key, offset)
}

// GetDel mocks base method.
func (m *MockUniversalClient) GetDel(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDel", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// GetEx mocks base method.
func (m *MockUniversalClient) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEx", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// GetRange mocks base method.
func (m *MockUniversalClient) GetRange(ctx context.Context, key string, start, end int64) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRange", ctx, key, start, end)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// GetRange indicates an expected call of GetRange.
func (mr *MockUniversalClientMockRecorder) GetRange(ctx, key, start, end any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockUniversalClient)(nil).GetRange), ctx, key, start, end)
}

// GetSet mocks base method.
func (m *MockUniversalClient) GetSet(ctx context.Context, key string, value any) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSet", ctx, key, value)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// GetSet indicates an expected call of GetSet.
func (mr *MockUniversalClientMockRecorder) GetSet(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockUniversalClient)(nil).GetSet), ctx, key, value)
}

// HDel mocks base method.
func (m *MockUniversalClient) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HDel", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HDel indicates an expected call of HDel.
func (mr *MockUniversalClientMockRecorder) HDel(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockUniversalClient)(nil).HDel), varargs...)
}

// HExists mocks base method.
func (m *MockUniversalClient) HExists(ctx context.Context, key, field string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HExists", ctx, key, field)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// HExists indicates an expected call of HExists.
func (mr *MockUniversalClientMockRecorder) HExists(ctx, key, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockUniversalClient)(nil).HExists), ctx, key, field)
}

// HExpire mocks base method.
func (m *MockUniversalClient) HExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpire", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpire indicates an expected call of HExpire.
func (mr *MockUniversalClientMockRecorder) HExpire(ctx, key, expiration any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpire", reflect.TypeOf((*MockUniversalClient)(nil).HExpire), varargs...)
}

// HExpireAt mocks base method.
func (m *MockUniversalClient) HExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireAt", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireAt indicates an expected call of HExpireAt.
func (mr *MockUniversalClientMockRecorder) HExpireAt(ctx, key, tm any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAt), varargs...)
}

// HExpireAtWithArgs mocks base method.
func (m *MockUniversalClient) HExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireAtWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireAtWithArgs indicates an expected call of HExpireAtWithArgs.
func (mr *MockUniversalClientMockRecorder) HExpireAtWithArgs(ctx, key, tm, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireAtWithArgs), varargs...)
}

// HExpireTime mocks base method.
func (m *MockUniversalClient) HExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireTime", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireTime indicates an expected call of HExpireTime.
func (mr *MockUniversalClientMockRecorder) HExpireTime(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HExpireTime), varargs...)
}

// HExpireWithArgs mocks base method.
func (m *MockUniversalClient) HExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HExpireWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HExpireWithArgs indicates an expected call of HExpireWithArgs.
func (mr *MockUniversalClientMockRecorder) HExpireWithArgs(ctx, key, expiration, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HExpireWithArgs), varargs...)
}

// HGet mocks base method.
func (m *MockUniversalClient) HGet(ctx context.Context, key, field string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGet", ctx, key, field)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// HGet indicates an expected call of HGet.
func (mr *MockUniversalClientMockRecorder) HGet(ctx, key, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockUniversalClient)(nil).HGet), ctx, key, field)
}

// HGetAll mocks base method.
func (m *MockUniversalClient) HGetAll(ctx context.Context, key string) *redis.MapStringStringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HGetAll", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringStringCmd)
	return ret0
}

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

// HGetDel mocks base method.
func (m *MockUniversalClient) HGetDel(ctx context.Context, key string, fields ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HGetDel", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HGetDel indicates an expected call of HGetDel.
func (mr *MockUniversalClientMockRecorder) HGetDel(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetDel", reflect.TypeOf((*MockUniversalClient)(nil).HGetDel), varargs...)
}

// HGetEX mocks base method.
func (m *MockUniversalClient) HGetEX(ctx context.Context, key string, fields ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HGetEX", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HGetEX indicates an expected call of HGetEX.
func (mr *MockUniversalClientMockRecorder) HGetEX(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetEX", reflect.TypeOf((*MockUniversalClient)(nil).HGetEX), varargs...)
}

// HGetEXWithArgs mocks base method.
func (m *MockUniversalClient) HGetEXWithArgs(ctx context.Context, key string, options *redis.HGetEXOptions, fields ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HGetEXWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HGetEXWithArgs indicates an expected call of HGetEXWithArgs.
func (mr *MockUniversalClientMockRecorder) HGetEXWithArgs(ctx, key, options any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetEXWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HGetEXWithArgs), varargs...)
}

// HIncrBy mocks base method.
func (m *MockUniversalClient) HIncrBy(ctx context.Context, key, field string, incr int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HIncrBy", ctx, key, field, incr)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HIncrBy indicates an expected call of HIncrBy.
func (mr *MockUniversalClientMockRecorder) HIncrBy(ctx, key, field, incr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).HIncrBy), ctx, key, field, incr)
}

// HIncrByFloat mocks base method.
func (m *MockUniversalClient) HIncrByFloat(ctx context.Context, key, field string, incr float64) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HIncrByFloat", ctx, key, field, incr)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// HIncrByFloat indicates an expected call of HIncrByFloat.
func (mr *MockUniversalClientMockRecorder) HIncrByFloat(ctx, key, field, incr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockUniversalClient)(nil).HIncrByFloat), ctx, key, field, incr)
}

// HKeys mocks base method.
func (m *MockUniversalClient) HKeys(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HKeys", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// HLen mocks base method.
func (m *MockUniversalClient) HLen(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HLen", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// HMGet mocks base method.
func (m *MockUniversalClient) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HMGet", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// HMGet indicates an expected call of HMGet.
func (mr *MockUniversalClientMockRecorder) HMGet(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockUniversalClient)(nil).HMGet), varargs...)
}

// HMSet mocks base method.
func (m *MockUniversalClient) HMSet(ctx context.Context, key string, values ...any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HMSet", varargs...)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// HMSet indicates an expected call of HMSet.
func (mr *MockUniversalClientMockRecorder) HMSet(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockUniversalClient)(nil).HMSet), varargs...)
}

// HPExpire mocks base method.
func (m *MockUniversalClient) HPExpire(ctx context.Context, key string, expiration time.Duration, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpire", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpire indicates an expected call of HPExpire.
func (mr *MockUniversalClientMockRecorder) HPExpire(ctx, key, expiration any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpire", reflect.TypeOf((*MockUniversalClient)(nil).HPExpire), varargs...)
}

// HPExpireAt mocks base method.
func (m *MockUniversalClient) HPExpireAt(ctx context.Context, key string, tm time.Time, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireAt", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireAt indicates an expected call of HPExpireAt.
func (mr *MockUniversalClientMockRecorder) HPExpireAt(ctx, key, tm any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAt), varargs...)
}

// HPExpireAtWithArgs mocks base method.
func (m *MockUniversalClient) HPExpireAtWithArgs(ctx context.Context, key string, tm time.Time, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, tm, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireAtWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireAtWithArgs indicates an expected call of HPExpireAtWithArgs.
func (mr *MockUniversalClientMockRecorder) HPExpireAtWithArgs(ctx, key, tm, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, tm, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireAtWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireAtWithArgs), varargs...)
}

// HPExpireTime mocks base method.
func (m *MockUniversalClient) HPExpireTime(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireTime", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireTime indicates an expected call of HPExpireTime.
func (mr *MockUniversalClientMockRecorder) HPExpireTime(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireTime), varargs...)
}

// HPExpireWithArgs mocks base method.
func (m *MockUniversalClient) HPExpireWithArgs(ctx context.Context, key string, expiration time.Duration, expirationArgs redis.HExpireArgs, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, expiration, expirationArgs}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPExpireWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPExpireWithArgs indicates an expected call of HPExpireWithArgs.
func (mr *MockUniversalClientMockRecorder) HPExpireWithArgs(ctx, key, expiration, expirationArgs any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, expiration, expirationArgs}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPExpireWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HPExpireWithArgs), varargs...)
}

// HPTTL mocks base method.
func (m *MockUniversalClient) HPTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPTTL", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPTTL indicates an expected call of HPTTL.
func (mr *MockUniversalClientMockRecorder) HPTTL(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPTTL", reflect.TypeOf((*MockUniversalClient)(nil).HPTTL), varargs...)
}

// HPersist mocks base method.
func (m *MockUniversalClient) HPersist(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HPersist", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HPersist indicates an expected call of HPersist.
func (mr *MockUniversalClientMockRecorder) HPersist(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HPersist", reflect.TypeOf((*MockUniversalClient)(nil).HPersist), varargs...)
}

// HRandField mocks base method.
func (m *MockUniversalClient) HRandField(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HRandField", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// HRandField indicates an expected call of HRandField.
func (mr *MockUniversalClientMockRecorder) HRandField(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockUniversalClient)(nil).HRandField), ctx, key, count)
}

// HRandFieldWithValues mocks base method.
func (m *MockUniversalClient) HRandFieldWithValues(ctx context.Context, key string, count int) *redis.KeyValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HRandFieldWithValues", ctx, key, count)
	ret0, _ := ret[0].(*redis.KeyValueSliceCmd)
	return ret0
}

// HRandFieldWithValues indicates an expected call of HRandFieldWithValues.
func (mr *MockUniversalClientMockRecorder) HRandFieldWithValues(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockUniversalClient)(nil).HRandFieldWithValues), ctx, key, count)
}

// HScan mocks base method.
func (m *MockUniversalClient) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HScan", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// HScan indicates an expected call of HScan.
func (mr *MockUniversalClientMockRecorder) HScan(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockUniversalClient)(nil).HScan), ctx, key, cursor, match, count)
}

// HScanNoValues mocks base method.
func (m *MockUniversalClient) HScanNoValues(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HScanNoValues", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// HScanNoValues indicates an expected call of HScanNoValues.
func (mr *MockUniversalClientMockRecorder) HScanNoValues(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScanNoValues", reflect.TypeOf((*MockUniversalClient)(nil).HScanNoValues), ctx, key, cursor, match, count)
}

// HSet mocks base method.
func (m *MockUniversalClient) HSet(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HSet", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HSet indicates an expected call of HSet.
func (mr *MockUniversalClientMockRecorder) HSet(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockUniversalClient)(nil).HSet), varargs...)
}

// HSetEX mocks base method.
func (m *MockUniversalClient) HSetEX(ctx context.Context, key string, fieldsAndValues ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fieldsAndValues {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HSetEX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HSetEX indicates an expected call of HSetEX.
func (mr *MockUniversalClientMockRecorder) HSetEX(ctx, key any, fieldsAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fieldsAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetEX", reflect.TypeOf((*MockUniversalClient)(nil).HSetEX), varargs...)
}

// HSetEXWithArgs mocks base method.
func (m *MockUniversalClient) HSetEXWithArgs(ctx context.Context, key string, options *redis.HSetEXOptions, fieldsAndValues ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range fieldsAndValues {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HSetEXWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HSetEXWithArgs indicates an expected call of HSetEXWithArgs.
func (mr *MockUniversalClientMockRecorder) HSetEXWithArgs(ctx, key, options any, fieldsAndValues ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, fieldsAndValues...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetEXWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).HSetEXWithArgs), varargs...)
}

// HSetNX mocks base method.
func (m *MockUniversalClient) HSetNX(ctx context.Context, key, field string, value any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HSetNX", ctx, key, field, value)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// HSetNX indicates an expected call of HSetNX.
func (mr *MockUniversalClientMockRecorder) HSetNX(ctx, key, field, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockUniversalClient)(nil).HSetNX), ctx, key, field, value)
}

// HStrLen mocks base method.
func (m *MockUniversalClient) HStrLen(ctx context.Context, key, field string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HStrLen", ctx, key, field)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// HStrLen indicates an expected call of HStrLen.
func (mr *MockUniversalClientMockRecorder) HStrLen(ctx, key, field any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HStrLen", reflect.TypeOf((*MockUniversalClient)(nil).HStrLen), ctx, key, field)
}

// HTTL mocks base method.
func (m *MockUniversalClient) HTTL(ctx context.Context, key string, fields ...string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range fields {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "HTTL", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// HTTL indicates an expected call of HTTL.
func (mr *MockUniversalClientMockRecorder) HTTL(ctx, key any, fields ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, fields...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HTTL", reflect.TypeOf((*MockUniversalClient)(nil).HTTL), varargs...)
}

// HVals mocks base method.
func (m *MockUniversalClient) HVals(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HVals", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// Incr mocks base method.
func (m *MockUniversalClient) Incr(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Incr", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// IncrBy mocks base method.
func (m *MockUniversalClient) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrBy", ctx, key, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// IncrBy indicates an expected call of IncrBy.
func (mr *MockUniversalClientMockRecorder) IncrBy(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockUniversalClient)(nil).IncrBy), ctx, key, value)
}

// IncrByFloat mocks base method.
func (m *MockUniversalClient) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncrByFloat", ctx, key, value)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// IncrByFloat indicates an expected call of IncrByFloat.
func (mr *MockUniversalClientMockRecorder) IncrByFloat(ctx, key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockUniversalClient)(nil).IncrByFloat), ctx, key, value)
}

// Info mocks base method.
func (m *MockUniversalClient) Info(ctx context.Context, section ...string) *redis.StringCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range section {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Info", varargs...)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// Info indicates an expected call of Info.
func (mr *MockUniversalClientMockRecorder) Info(ctx any, section ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, section...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockUniversalClient)(nil).Info), varargs...)
}

// JSONArrAppend mocks base method.
func (m *MockUniversalClient) JSONArrAppend(ctx context.Context, key, path string, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrAppend", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrAppend indicates an expected call of JSONArrAppend.
func (mr *MockUniversalClientMockRecorder) JSONArrAppend(ctx, key, path any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrAppend", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrAppend), varargs...)
}

// JSONArrIndex mocks base method.
func (m *MockUniversalClient) JSONArrIndex(ctx context.Context, key, path string, value ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path}
	for _, a := range value {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrIndex", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrIndex indicates an expected call of JSONArrIndex.
func (mr *MockUniversalClientMockRecorder) JSONArrIndex(ctx, key, path any, value ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path}, value...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndex", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrIndex), varargs...)
}

// JSONArrIndexWithArgs mocks base method.
func (m *MockUniversalClient) JSONArrIndexWithArgs(ctx context.Context, key, path string, options *redis.JSONArrIndexArgs, value ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path, options}
	for _, a := range value {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrIndexWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrIndexWithArgs indicates an expected call of JSONArrIndexWithArgs.
func (mr *MockUniversalClientMockRecorder) JSONArrIndexWithArgs(ctx, key, path, options any, value ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path, options}, value...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrIndexWithArgs), varargs...)
}

// JSONArrInsert mocks base method.
func (m *MockUniversalClient) JSONArrInsert(ctx context.Context, key, path string, index int64, values ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, path, index}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONArrInsert", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrInsert indicates an expected call of JSONArrInsert.
func (mr *MockUniversalClientMockRecorder) JSONArrInsert(ctx, key, path, index any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, path, index}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrInsert", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrInsert), varargs...)
}

// JSONArrLen mocks base method.
func (m *MockUniversalClient) JSONArrLen(ctx context.Context, key, path string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrLen", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrLen indicates an expected call of JSONArrLen.
func (mr *MockUniversalClientMockRecorder) JSONArrLen(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrLen), ctx, key, path)
}

// JSONArrPop mocks base method.
func (m *MockUniversalClient) JSONArrPop(ctx context.Context, key, path string, index int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrPop", ctx, key, path, index)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// JSONArrPop indicates an expected call of JSONArrPop.
func (mr *MockUniversalClientMockRecorder) JSONArrPop(ctx, key, path, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrPop", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrPop), ctx, key, path, index)
}

// JSONArrTrim mocks base method.
func (m *MockUniversalClient) JSONArrTrim(ctx context.Context, key, path string) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrTrim", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrTrim indicates an expected call of JSONArrTrim.
func (mr *MockUniversalClientMockRecorder) JSONArrTrim(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrim", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrTrim), ctx, key, path)
}

// JSONArrTrimWithArgs mocks base method.
func (m *MockUniversalClient) JSONArrTrimWithArgs(ctx context.Context, key, path string, options *redis.JSONArrTrimArgs) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONArrTrimWithArgs", ctx, key, path, options)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// JSONArrTrimWithArgs indicates an expected call of JSONArrTrimWithArgs.
func (mr *MockUniversalClientMockRecorder) JSONArrTrimWithArgs(ctx, key, path, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrimWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrTrimWithArgs), ctx, key, path, options)
}

// JSONClear mocks base method.
func (m *MockUniversalClient) JSONClear(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONClear", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONClear indicates an expected call of JSONClear.
func (mr *MockUniversalClientMockRecorder) JSONClear(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONClear", reflect.TypeOf((*MockUniversalClient)(nil).JSONClear), ctx, key, path)
}

// JSONDebugMemory mocks base method.
func (m *MockUniversalClient) JSONDebugMemory(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONDebugMemory", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONDebugMemory indicates an expected call of JSONDebugMemory.
func (mr *MockUniversalClientMockRecorder) JSONDebugMemory(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDebugMemory", reflect.TypeOf((*MockUniversalClient)(nil).JSONDebugMemory), ctx, key, path)
}

// JSONDel mocks base method.
func (m *MockUniversalClient) JSONDel(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONDel", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONDel indicates an expected call of JSONDel.
func (mr *MockUniversalClientMockRecorder) JSONDel(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDel", reflect.TypeOf((*MockUniversalClient)(nil).JSONDel), ctx, key, path)
}

// JSONForget mocks base method.
func (m *MockUniversalClient) JSONForget(ctx context.Context, key, path string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONForget", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// JSONForget indicates an expected call of JSONForget.
func (mr *MockUniversalClientMockRecorder) JSONForget(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONForget", reflect.TypeOf((*MockUniversalClient)(nil).JSONForget), ctx, key, path)
}

// JSONGet mocks base method.
func (m *MockUniversalClient) JSONGet(ctx context.Context, key string, paths ...string) *redis.JSONCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range paths {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONGet", varargs...)
	ret0, _ := ret[0].(*redis.JSONCmd)
	return ret0
}

// JSONGet indicates an expected call of JSONGet.
func (mr *MockUniversalClientMockRecorder) JSONGet(ctx, key any, paths ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, paths...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGet", reflect.TypeOf((*MockUniversalClient)(nil).JSONGet), varargs...)
}

// JSONGetWithArgs mocks base method.
func (m *MockUniversalClient) JSONGetWithArgs(ctx context.Context, key string, options *redis.JSONGetArgs, paths ...string) *redis.JSONCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key, options}
	for _, a := range paths {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONGetWithArgs", varargs...)
	ret0, _ := ret[0].(*redis.JSONCmd)
	return ret0
}

// JSONGetWithArgs indicates an expected call of JSONGetWithArgs.
func (mr *MockUniversalClientMockRecorder) JSONGetWithArgs(ctx, key, options any, paths ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key, options}, paths...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONGetWithArgs), varargs...)
}

// JSONMGet mocks base method.
func (m *MockUniversalClient) JSONMGet(ctx context.Context, path string, keys ...string) *redis.JSONSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, path}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONMGet", varargs...)
	ret0, _ := ret[0].(*redis.JSONSliceCmd)
	return ret0
}

// JSONMGet indicates an expected call of JSONMGet.
func (mr *MockUniversalClientMockRecorder) JSONMGet(ctx, path any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, path}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMGet", reflect.TypeOf((*MockUniversalClient)(nil).JSONMGet), varargs...)
}

// JSONMSet mocks base method.
func (m *MockUniversalClient) JSONMSet(ctx context.Context, params ...any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range params {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "JSONMSet", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONMSet indicates an expected call of JSONMSet.
func (mr *MockUniversalClientMockRecorder) JSONMSet(ctx any, params ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, params...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSet", reflect.TypeOf((*MockUniversalClient)(nil).JSONMSet), varargs...)
}

// JSONMSetArgs mocks base method.
func (m *MockUniversalClient) JSONMSetArgs(ctx context.Context, docs []redis.JSONSetArgs) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONMSetArgs", ctx, docs)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONMSetArgs indicates an expected call of JSONMSetArgs.
func (mr *MockUniversalClientMockRecorder) JSONMSetArgs(ctx, docs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSetArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONMSetArgs), ctx, docs)
}

// JSONMerge mocks base method.
func (m *MockUniversalClient) JSONMerge(ctx context.Context, key, path, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONMerge", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONMerge indicates an expected call of JSONMerge.
func (mr *MockUniversalClientMockRecorder) JSONMerge(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMerge", reflect.TypeOf((*MockUniversalClient)(nil).JSONMerge), ctx, key, path, value)
}

// JSONNumIncrBy mocks base method.
func (m *MockUniversalClient) JSONNumIncrBy(ctx context.Context, key, path string, value float64) *redis.JSONCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONNumIncrBy", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.JSONCmd)
	return ret0
}

// JSONNumIncrBy indicates an expected call of JSONNumIncrBy.
func (mr *MockUniversalClientMockRecorder) JSONNumIncrBy(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONNumIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).JSONNumIncrBy), ctx, key, path, value)
}

// JSONObjKeys mocks base method.
func (m *MockUniversalClient) JSONObjKeys(ctx context.Context, key, path string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONObjKeys", ctx, key, path)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// JSONObjKeys indicates an expected call of JSONObjKeys.
func (mr *MockUniversalClientMockRecorder) JSONObjKeys(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjKeys", reflect.TypeOf((*MockUniversalClient)(nil).JSONObjKeys), ctx, key, path)
}

// JSONObjLen mocks base method.
func (m *MockUniversalClient) JSONObjLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONObjLen", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONObjLen indicates an expected call of JSONObjLen.
func (mr *MockUniversalClientMockRecorder) JSONObjLen(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONObjLen), ctx, key, path)
}

// JSONSet mocks base method.
func (m *MockUniversalClient) JSONSet(ctx context.Context, key, path string, value any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONSet", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONSet indicates an expected call of JSONSet.
func (mr *MockUniversalClientMockRecorder) JSONSet(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSet", reflect.TypeOf((*MockUniversalClient)(nil).JSONSet), ctx, key, path, value)
}

// JSONSetMode mocks base method.
func (m *MockUniversalClient) JSONSetMode(ctx context.Context, key, path string, value any, mode string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONSetMode", ctx, key, path, value, mode)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// JSONSetMode indicates an expected call of JSONSetMode.
func (mr *MockUniversalClientMockRecorder) JSONSetMode(ctx, key, path, value, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSetMode", reflect.TypeOf((*MockUniversalClient)(nil).JSONSetMode), ctx, key, path, value, mode)
}

// JSONStrAppend mocks base method.
func (m *MockUniversalClient) JSONStrAppend(ctx context.Context, key, path, value string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONStrAppend", ctx, key, path, value)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONStrAppend indicates an expected call of JSONStrAppend.
func (mr *MockUniversalClientMockRecorder) JSONStrAppend(ctx, key, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrAppend", reflect.TypeOf((*MockUniversalClient)(nil).JSONStrAppend), ctx, key, path, value)
}

// JSONStrLen mocks base method.
func (m *MockUniversalClient) JSONStrLen(ctx context.Context, key, path string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONStrLen", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONStrLen indicates an expected call of JSONStrLen.
func (mr *MockUniversalClientMockRecorder) JSONStrLen(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONStrLen), ctx, key, path)
}

// JSONToggle mocks base method.
func (m *MockUniversalClient) JSONToggle(ctx context.Context, key, path string) *redis.IntPointerSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONToggle", ctx, key, path)
	ret0, _ := ret[0].(*redis.IntPointerSliceCmd)
	return ret0
}

// JSONToggle indicates an expected call of JSONToggle.
func (mr *MockUniversalClientMockRecorder) JSONToggle(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONToggle", reflect.TypeOf((*MockUniversalClient)(nil).JSONToggle), ctx, key, path)
}

// JSONType mocks base method.
func (m *MockUniversalClient) JSONType(ctx context.Context, key, path string) *redis.JSONSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSONType", ctx, key, path)
	ret0, _ := ret[0].(*redis.JSONSliceCmd)
	return ret0
}

// JSONType indicates an expected call of JSONType.
func (mr *MockUniversalClientMockRecorder) JSONType(ctx, key, path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONType", reflect.TypeOf((*MockUniversalClient)(nil).JSONType), ctx, key, path)
}

// Keys mocks base method.
func (m *MockUniversalClient) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Keys", ctx, pattern)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// LCS mocks base method.
func (m *MockUniversalClient) LCS(ctx context.Context, q *redis.LCSQuery) *redis.LCSCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LCS", ctx, q)
	ret0, _ := ret[0].(*redis.LCSCmd)
	return ret0
}

// LCS indicates an expected call of LCS.
func (mr *MockUniversalClientMockRecorder) LCS(ctx, q any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockUniversalClient)(nil).LCS), ctx, q)
}

// LIndex mocks base method.
func (m *MockUniversalClient) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LIndex", ctx, key, index)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// LIndex indicates an expected call of LIndex.
func (mr *MockUniversalClientMockRecorder) LIndex(ctx, key, index any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockUniversalClient)(nil).LIndex), ctx, key, index)
}

// LInsert mocks base method.
func (m *MockUniversalClient) LInsert(ctx context.Context, key, op string, pivot, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LInsert", ctx, key, op, pivot, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LInsert indicates an expected call of LInsert.
func (mr *MockUniversalClientMockRecorder) LInsert(ctx, key, op, pivot, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockUniversalClient)(nil).LInsert), ctx, key, op, pivot, value)
}

// LInsertAfter mocks base method.
func (m *MockUniversalClient) LInsertAfter(ctx context.Context, key string, pivot, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LInsertAfter", ctx, key, pivot, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LInsertAfter indicates an expected call of LInsertAfter.
func (mr *MockUniversalClientMockRecorder) LInsertAfter(ctx, key, pivot, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockUniversalClient)(nil).LInsertAfter), ctx, key, pivot, value)
}

// LInsertBefore mocks base method.
func (m *MockUniversalClient) LInsertBefore(ctx context.Context, key string, pivot, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LInsertBefore", ctx, key, pivot, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LInsertBefore indicates an expected call of LInsertBefore.
func (mr *MockUniversalClientMockRecorder) LInsertBefore(ctx, key, pivot, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockUniversalClient)(nil).LInsertBefore), ctx, key, pivot, value)
}

// LLen mocks base method.
func (m *MockUniversalClient) LLen(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LLen", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// LMPop mocks base method.
func (m *MockUniversalClient) LMPop(ctx context.Context, direction string, count int64, keys ...string) *redis.KeyValuesCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, direction, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LMPop", varargs...)
	ret0, _ := ret[0].(*redis.KeyValuesCmd)
	return ret0
}

// LMPop indicates an expected call of LMPop.
func (mr *MockUniversalClientMockRecorder) LMPop(ctx, direction, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, direction, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockUniversalClient)(nil).LMPop), varargs...)
}

// LMove mocks base method.
func (m *MockUniversalClient) LMove(ctx context.Context, source, destination, srcpos, destpos string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LMove", ctx, source, destination, srcpos, destpos)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// LMove indicates an expected call of LMove.
func (mr *MockUniversalClientMockRecorder) LMove(ctx, source, destination, srcpos, destpos any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockUniversalClient)(nil).LMove), ctx, source, destination, srcpos, destpos)
}

// LPop mocks base method.
func (m *MockUniversalClient) LPop(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPop", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// LPopCount mocks base method.
func (m *MockUniversalClient) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPopCount", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// LPopCount indicates an expected call of LPopCount.
func (mr *MockUniversalClientMockRecorder) LPopCount(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockUniversalClient)(nil).LPopCount), ctx, key, count)
}

// LPos mocks base method.
func (m *MockUniversalClient) LPos(ctx context.Context, key, value string, args redis.LPosArgs) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPos", ctx, key, value, args)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LPos indicates an expected call of LPos.
func (mr *MockUniversalClientMockRecorder) LPos(ctx, key, value, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockUniversalClient)(nil).LPos), ctx, key, value, args)
}

// LPosCount mocks base method.
func (m *MockUniversalClient) LPosCount(ctx context.Context, key, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LPosCount", ctx, key, value, count, args)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// LPosCount indicates an expected call of LPosCount.
func (mr *MockUniversalClientMockRecorder) LPosCount(ctx, key, value, count, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockUniversalClient)(nil).LPosCount), ctx, key, value, count, args)
}

// LPush mocks base method.
func (m *MockUniversalClient) LPush(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LPush", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LPush indicates an expected call of LPush.
func (mr *MockUniversalClientMockRecorder) LPush(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockUniversalClient)(nil).LPush), varargs...)
}

// LPushX mocks base method.
func (m *MockUniversalClient) LPushX(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "LPushX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LPushX indicates an expected call of LPushX.
func (mr *MockUniversalClientMockRecorder) LPushX(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockUniversalClient)(nil).LPushX), varargs...)
}

// LRange mocks base method.
func (m *MockUniversalClient) LRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRange", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// LRange indicates an expected call of LRange.
func (mr *MockUniversalClientMockRecorder) LRange(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockUniversalClient)(nil).LRange), ctx, key, start, stop)
}

// LRem mocks base method.
func (m *MockUniversalClient) LRem(ctx context.Context, key string, count int64, value any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LRem", ctx, key, count, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LRem indicates an expected call of LRem.
func (mr *MockUniversalClientMockRecorder) LRem(ctx, key, count, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockUniversalClient)(nil).LRem), ctx, key, count, value)
}

// LSet mocks base method.
func (m *MockUniversalClient) LSet(ctx context.Context, key string, index int64, value any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LSet", ctx, key, index, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// LSet indicates an expected call of LSet.
func (mr *MockUniversalClientMockRecorder) LSet(ctx, key, index, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockUniversalClient)(nil).LSet), ctx, key, index, value)
}

// LTrim mocks base method.
func (m *MockUniversalClient) LTrim(ctx context.Context, key string, start, stop int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LTrim", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// LTrim indicates an expected call of LTrim.
func (mr *MockUniversalClientMockRecorder) LTrim(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockUniversalClient)(nil).LTrim), ctx, key, start, stop)
}

// LastSave mocks base method.
func (m *MockUniversalClient) LastSave(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LastSave", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// LastSave indicates an expected call of LastSave.
func (mr *MockUniversalClientMockRecorder) LastSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockUniversalClient)(nil).LastSave), ctx)
}

// MGet mocks base method.
func (m *MockUniversalClient) MGet(ctx context.Context, keys ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MGet", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// MGet indicates an expected call of MGet.
func (mr *MockUniversalClientMockRecorder) MGet(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockUniversalClient)(nil).MGet), varargs...)
}

// MSet mocks base method.
func (m *MockUniversalClient) MSet(ctx context.Context, values ...any) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MSet", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// MSet indicates an expected call of MSet.
func (mr *MockUniversalClientMockRecorder) MSet(ctx any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockUniversalClient)(nil).MSet), varargs...)
}

// MSetNX mocks base method.
func (m *MockUniversalClient) MSetNX(ctx context.Context, values ...any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MSetNX", varargs...)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// MSetNX indicates an expected call of MSetNX.
func (mr *MockUniversalClientMockRecorder) MSetNX(ctx any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockUniversalClient)(nil).MSetNX), varargs...)
}

// MemoryUsage mocks base method.
func (m *MockUniversalClient) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range samples {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MemoryUsage", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// MemoryUsage indicates an expected call of MemoryUsage.
func (mr *MockUniversalClientMockRecorder) MemoryUsage(ctx, key any, samples ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, samples...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockUniversalClient)(nil).MemoryUsage), varargs...)
}

// Migrate mocks base method.
func (m *MockUniversalClient) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Migrate", ctx, host, port, key, db, timeout)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Migrate indicates an expected call of Migrate.
func (mr *MockUniversalClientMockRecorder) Migrate(ctx, host, port, key, db, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockUniversalClient)(nil).Migrate), ctx, host, port, key, db, timeout)
}

// ModuleLoadex mocks base method.
func (m *MockUniversalClient) ModuleLoadex(ctx context.Context, conf *redis.ModuleLoadexConfig) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ModuleLoadex", ctx, conf)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ModuleLoadex indicates an expected call of ModuleLoadex.
func (mr *MockUniversalClientMockRecorder) ModuleLoadex(ctx, conf any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockUniversalClient)(nil).ModuleLoadex), ctx, conf)
}

// Move mocks base method.
func (m *MockUniversalClient) Move(ctx context.Context, key string, db int) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Move", ctx, key, db)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// Move indicates an expected call of Move.
func (mr *MockUniversalClientMockRecorder) Move(ctx, key, db any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockUniversalClient)(nil).Move), ctx, key, db)
}

// ObjectEncoding mocks base method.
func (m *MockUniversalClient) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectEncoding", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// ObjectFreq mocks base method.
func (m *MockUniversalClient) ObjectFreq(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectFreq", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// ObjectIdleTime mocks base method.
func (m *MockUniversalClient) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectIdleTime", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// ObjectRefCount mocks base method.
func (m *MockUniversalClient) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ObjectRefCount", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// PExpire mocks base method.
func (m *MockUniversalClient) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PExpire", ctx, key, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// PExpireAt mocks base method.
func (m *MockUniversalClient) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PExpireAt", ctx, key, tm)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// PExpireAt indicates an expected call of PExpireAt.
func (mr *MockUniversalClientMockRecorder) PExpireAt(ctx, key, tm any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).PExpireAt), ctx, key, tm)
}

// PExpireTime mocks base method.
func (m *MockUniversalClient) PExpireTime(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PExpireTime", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// PFAdd mocks base method.
func (m *MockUniversalClient) PFAdd(ctx context.Context, key string, els ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range els {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// PFCount mocks base method.
func (m *MockUniversalClient) PFCount(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFCount", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// PFCount indicates an expected call of PFCount.
func (mr *MockUniversalClientMockRecorder) PFCount(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockUniversalClient)(nil).PFCount), varargs...)
}

// PFMerge mocks base method.
func (m *MockUniversalClient) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, dest}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PFMerge", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// PSubscribe mocks base method.
func (m *MockUniversalClient) PSubscribe(ctx context.Context, channels ...string) *redis.PubSub {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PSubscribe", varargs...)
	ret0, _ := ret[0].(*redis.PubSub)
	return ret0
}

// PSubscribe indicates an expected call of PSubscribe.
func (mr *MockUniversalClientMockRecorder) PSubscribe(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PSubscribe", reflect.TypeOf((*MockUniversalClient)(nil).PSubscribe), varargs...)
}

// PTTL mocks base method.
func (m *MockUniversalClient) PTTL(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PTTL", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// Persist mocks base method.
func (m *MockUniversalClient) Persist(ctx context.Context, key string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Persist", ctx, key)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// Ping mocks base method.
func (m *MockUniversalClient) Ping(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ping", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Ping indicates an expected call of Ping.
func (mr *MockUniversalClientMockRecorder) Ping(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockUniversalClient)(nil).Ping), ctx)
}

// Pipeline mocks base method.
func (m *MockUniversalClient) Pipeline() redis.Pipeliner {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipeline")
	ret0, _ := ret[0].(redis.Pipeliner)
	return ret0
}

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

// Pipelined mocks base method.
func (m *MockUniversalClient) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Pipelined", ctx, fn)
	ret0, _ := ret[0].([]redis.Cmder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Pipelined indicates an expected call of Pipelined.
func (mr *MockUniversalClientMockRecorder) Pipelined(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockUniversalClient)(nil).Pipelined), ctx, fn)
}

// PoolStats mocks base method.
func (m *MockUniversalClient) PoolStats() *redis.PoolStats {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PoolStats")
	ret0, _ := ret[0].(*redis.PoolStats)
	return ret0
}

// PoolStats indicates an expected call of PoolStats.
func (mr *MockUniversalClientMockRecorder) PoolStats() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolStats", reflect.TypeOf((*MockUniversalClient)(nil).PoolStats))
}

// Process mocks base method.
func (m *MockUniversalClient) Process(ctx context.Context, cmd redis.Cmder) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Process", ctx, cmd)
	ret0, _ := ret[0].(error)
	return ret0
}

// Process indicates an expected call of Process.
func (mr *MockUniversalClientMockRecorder) Process(ctx, cmd any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockUniversalClient)(nil).Process), ctx, cmd)
}

// PubSubChannels mocks base method.
func (m *MockUniversalClient) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PubSubChannels", ctx, pattern)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// PubSubChannels indicates an expected call of PubSubChannels.
func (mr *MockUniversalClientMockRecorder) PubSubChannels(ctx, pattern any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockUniversalClient)(nil).PubSubChannels), ctx, pattern)
}

// PubSubNumPat mocks base method.
func (m *MockUniversalClient) PubSubNumPat(ctx context.Context) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PubSubNumPat", ctx)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// PubSubNumPat indicates an expected call of PubSubNumPat.
func (mr *MockUniversalClientMockRecorder) PubSubNumPat(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockUniversalClient)(nil).PubSubNumPat), ctx)
}

// PubSubNumSub mocks base method.
func (m *MockUniversalClient) PubSubNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PubSubNumSub", varargs...)
	ret0, _ := ret[0].(*redis.MapStringIntCmd)
	return ret0
}

// PubSubNumSub indicates an expected call of PubSubNumSub.
func (mr *MockUniversalClientMockRecorder) PubSubNumSub(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockUniversalClient)(nil).PubSubNumSub), varargs...)
}

// PubSubShardChannels mocks base method.
func (m *MockUniversalClient) PubSubShardChannels(ctx context.Context, pattern string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PubSubShardChannels", ctx, pattern)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// PubSubShardChannels indicates an expected call of PubSubShardChannels.
func (mr *MockUniversalClientMockRecorder) PubSubShardChannels(ctx, pattern any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockUniversalClient)(nil).PubSubShardChannels), ctx, pattern)
}

// PubSubShardNumSub mocks base method.
func (m *MockUniversalClient) PubSubShardNumSub(ctx context.Context, channels ...string) *redis.MapStringIntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...)
	ret0, _ := ret[0].(*redis.MapStringIntCmd)
	return ret0
}

// PubSubShardNumSub indicates an expected call of PubSubShardNumSub.
func (mr *MockUniversalClientMockRecorder) PubSubShardNumSub(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockUniversalClient)(nil).PubSubShardNumSub), varargs...)
}

// Publish mocks base method.
func (m *MockUniversalClient) Publish(ctx context.Context, channel string, message any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Publish", ctx, channel, message)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Publish indicates an expected call of Publish.
func (mr *MockUniversalClientMockRecorder) Publish(ctx, channel, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockUniversalClient)(nil).Publish), ctx, channel, message)
}

// Quit mocks base method.
func (m *MockUniversalClient) Quit(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Quit", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Quit indicates an expected call of Quit.
func (mr *MockUniversalClientMockRecorder) Quit(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockUniversalClient)(nil).Quit), ctx)
}

// RPop mocks base method.
func (m *MockUniversalClient) RPop(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPop", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// RPopCount mocks base method.
func (m *MockUniversalClient) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPopCount", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// RPopCount indicates an expected call of RPopCount.
func (mr *MockUniversalClientMockRecorder) RPopCount(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockUniversalClient)(nil).RPopCount), ctx, key, count)
}

// RPopLPush mocks base method.
func (m *MockUniversalClient) RPopLPush(ctx context.Context, source, destination string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RPopLPush", ctx, source, destination)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// RPopLPush indicates an expected call of RPopLPush.
func (mr *MockUniversalClientMockRecorder) RPopLPush(ctx, source, destination any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockUniversalClient)(nil).RPopLPush), ctx, source, destination)
}

// RPush mocks base method.
func (m *MockUniversalClient) RPush(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RPush", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// RPush indicates an expected call of RPush.
func (mr *MockUniversalClientMockRecorder) RPush(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockUniversalClient)(nil).RPush), varargs...)
}

// RPushX mocks base method.
func (m *MockUniversalClient) RPushX(ctx context.Context, key string, values ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RPushX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// RPushX indicates an expected call of RPushX.
func (mr *MockUniversalClientMockRecorder) RPushX(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockUniversalClient)(nil).RPushX), varargs...)
}

// RandomKey mocks base method.
func (m *MockUniversalClient) RandomKey(ctx context.Context) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RandomKey", ctx)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// RandomKey indicates an expected call of RandomKey.
func (mr *MockUniversalClientMockRecorder) RandomKey(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockUniversalClient)(nil).RandomKey), ctx)
}

// ReadOnly mocks base method.
func (m *MockUniversalClient) ReadOnly(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadOnly", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ReadOnly indicates an expected call of ReadOnly.
func (mr *MockUniversalClientMockRecorder) ReadOnly(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockUniversalClient)(nil).ReadOnly), ctx)
}

// ReadWrite mocks base method.
func (m *MockUniversalClient) ReadWrite(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadWrite", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ReadWrite indicates an expected call of ReadWrite.
func (mr *MockUniversalClientMockRecorder) ReadWrite(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockUniversalClient)(nil).ReadWrite), ctx)
}

// Rename mocks base method.
func (m *MockUniversalClient) Rename(ctx context.Context, key, newkey string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Rename", ctx, key, newkey)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Rename indicates an expected call of Rename.
func (mr *MockUniversalClientMockRecorder) Rename(ctx, key, newkey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockUniversalClient)(nil).Rename), ctx, key, newkey)
}

// RenameNX mocks base method.
func (m *MockUniversalClient) RenameNX(ctx context.Context, key, newkey string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenameNX", ctx, key, newkey)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// RenameNX indicates an expected call of RenameNX.
func (mr *MockUniversalClientMockRecorder) RenameNX(ctx, key, newkey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockUniversalClient)(nil).RenameNX), ctx, key, newkey)
}

// Restore mocks base method.
func (m *MockUniversalClient) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Restore", ctx, key, ttl, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Restore indicates an expected call of Restore.
func (mr *MockUniversalClientMockRecorder) Restore(ctx, key, ttl, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockUniversalClient)(nil).Restore), ctx, key, ttl, value)
}

// RestoreReplace mocks base method.
func (m *MockUniversalClient) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreReplace", ctx, key, ttl, value)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// RestoreReplace indicates an expected call of RestoreReplace.
func (mr *MockUniversalClientMockRecorder) RestoreReplace(ctx, key, ttl, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockUniversalClient)(nil).RestoreReplace), ctx, key, ttl, value)
}

// SAdd mocks base method.
func (m *MockUniversalClient) SAdd(ctx context.Context, key string, members ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SAdd indicates an expected call of SAdd.
func (mr *MockUniversalClientMockRecorder) SAdd(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockUniversalClient)(nil).SAdd), varargs...)
}

// SCard mocks base method.
func (m *MockUniversalClient) SCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// SDiff mocks base method.
func (m *MockUniversalClient) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SDiff", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SDiff indicates an expected call of SDiff.
func (mr *MockUniversalClientMockRecorder) SDiff(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockUniversalClient)(nil).SDiff), varargs...)
}

// SDiffStore mocks base method.
func (m *MockUniversalClient) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SDiffStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SDiffStore indicates an expected call of SDiffStore.
func (mr *MockUniversalClientMockRecorder) SDiffStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockUniversalClient)(nil).SDiffStore), varargs...)
}

// SInter mocks base method.
func (m *MockUniversalClient) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SInter", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SInter indicates an expected call of SInter.
func (mr *MockUniversalClientMockRecorder) SInter(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockUniversalClient)(nil).SInter), varargs...)
}

// SInterCard mocks base method.
func (m *MockUniversalClient) SInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, limit}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SInterCard", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SInterCard indicates an expected call of SInterCard.
func (mr *MockUniversalClientMockRecorder) SInterCard(ctx, limit any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, limit}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockUniversalClient)(nil).SInterCard), varargs...)
}

// SInterStore mocks base method.
func (m *MockUniversalClient) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SInterStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SInterStore indicates an expected call of SInterStore.
func (mr *MockUniversalClientMockRecorder) SInterStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockUniversalClient)(nil).SInterStore), varargs...)
}

// SIsMember mocks base method.
func (m *MockUniversalClient) SIsMember(ctx context.Context, key string, member any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SIsMember", ctx, key, member)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// SIsMember indicates an expected call of SIsMember.
func (mr *MockUniversalClientMockRecorder) SIsMember(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockUniversalClient)(nil).SIsMember), ctx, key, member)
}

// SMIsMember mocks base method.
func (m *MockUniversalClient) SMIsMember(ctx context.Context, key string, members ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SMIsMember", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// SMIsMember indicates an expected call of SMIsMember.
func (mr *MockUniversalClientMockRecorder) SMIsMember(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockUniversalClient)(nil).SMIsMember), varargs...)
}

// SMembers mocks base method.
func (m *MockUniversalClient) SMembers(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembers", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// SMembersMap mocks base method.
func (m *MockUniversalClient) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMembersMap", ctx, key)
	ret0, _ := ret[0].(*redis.StringStructMapCmd)
	return ret0
}

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

// SMove mocks base method.
func (m *MockUniversalClient) SMove(ctx context.Context, source, destination string, member any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SMove", ctx, source, destination, member)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// SMove indicates an expected call of SMove.
func (mr *MockUniversalClientMockRecorder) SMove(ctx, source, destination, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockUniversalClient)(nil).SMove), ctx, source, destination, member)
}

// SPop mocks base method.
func (m *MockUniversalClient) SPop(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPop", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// SPopN mocks base method.
func (m *MockUniversalClient) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPopN", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SPopN indicates an expected call of SPopN.
func (mr *MockUniversalClientMockRecorder) SPopN(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockUniversalClient)(nil).SPopN), ctx, key, count)
}

// SPublish mocks base method.
func (m *MockUniversalClient) SPublish(ctx context.Context, channel string, message any) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SPublish", ctx, channel, message)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SPublish indicates an expected call of SPublish.
func (mr *MockUniversalClientMockRecorder) SPublish(ctx, channel, message any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockUniversalClient)(nil).SPublish), ctx, channel, message)
}

// SRandMember mocks base method.
func (m *MockUniversalClient) SRandMember(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SRandMember", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// SRandMemberN mocks base method.
func (m *MockUniversalClient) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SRandMemberN", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SRandMemberN indicates an expected call of SRandMemberN.
func (mr *MockUniversalClientMockRecorder) SRandMemberN(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockUniversalClient)(nil).SRandMemberN), ctx, key, count)
}

// SRem mocks base method.
func (m *MockUniversalClient) SRem(ctx context.Context, key string, members ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SRem", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SRem indicates an expected call of SRem.
func (mr *MockUniversalClientMockRecorder) SRem(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockUniversalClient)(nil).SRem), varargs...)
}

// SScan mocks base method.
func (m *MockUniversalClient) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SScan", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// SScan indicates an expected call of SScan.
func (mr *MockUniversalClientMockRecorder) SScan(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockUniversalClient)(nil).SScan), ctx, key, cursor, match, count)
}

// SSubscribe mocks base method.
func (m *MockUniversalClient) SSubscribe(ctx context.Context, channels ...string) *redis.PubSub {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SSubscribe", varargs...)
	ret0, _ := ret[0].(*redis.PubSub)
	return ret0
}

// SSubscribe indicates an expected call of SSubscribe.
func (mr *MockUniversalClientMockRecorder) SSubscribe(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SSubscribe", reflect.TypeOf((*MockUniversalClient)(nil).SSubscribe), varargs...)
}

// SUnion mocks base method.
func (m *MockUniversalClient) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SUnion", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SUnion indicates an expected call of SUnion.
func (mr *MockUniversalClientMockRecorder) SUnion(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockUniversalClient)(nil).SUnion), varargs...)
}

// SUnionStore mocks base method.
func (m *MockUniversalClient) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SUnionStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SUnionStore indicates an expected call of SUnionStore.
func (mr *MockUniversalClientMockRecorder) SUnionStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockUniversalClient)(nil).SUnionStore), varargs...)
}

// Save mocks base method.
func (m *MockUniversalClient) Save(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Save indicates an expected call of Save.
func (mr *MockUniversalClientMockRecorder) Save(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockUniversalClient)(nil).Save), ctx)
}

// Scan mocks base method.
func (m *MockUniversalClient) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Scan", ctx, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

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

// ScanType mocks base method.
func (m *MockUniversalClient) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScanType", ctx, cursor, match, count, keyType)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// ScanType indicates an expected call of ScanType.
func (mr *MockUniversalClientMockRecorder) ScanType(ctx, cursor, match, count, keyType any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockUniversalClient)(nil).ScanType), ctx, cursor, match, count, keyType)
}

// ScriptExists mocks base method.
func (m *MockUniversalClient) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range hashes {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ScriptExists", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// ScriptExists indicates an expected call of ScriptExists.
func (mr *MockUniversalClientMockRecorder) ScriptExists(ctx any, hashes ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, hashes...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockUniversalClient)(nil).ScriptExists), varargs...)
}

// ScriptFlush mocks base method.
func (m *MockUniversalClient) ScriptFlush(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScriptFlush", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ScriptFlush indicates an expected call of ScriptFlush.
func (mr *MockUniversalClientMockRecorder) ScriptFlush(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockUniversalClient)(nil).ScriptFlush), ctx)
}

// ScriptKill mocks base method.
func (m *MockUniversalClient) ScriptKill(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScriptKill", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ScriptKill indicates an expected call of ScriptKill.
func (mr *MockUniversalClientMockRecorder) ScriptKill(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockUniversalClient)(nil).ScriptKill), ctx)
}

// ScriptLoad mocks base method.
func (m *MockUniversalClient) ScriptLoad(ctx context.Context, script string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ScriptLoad", ctx, script)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// ScriptLoad indicates an expected call of ScriptLoad.
func (mr *MockUniversalClientMockRecorder) ScriptLoad(ctx, script any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockUniversalClient)(nil).ScriptLoad), ctx, script)
}

// Set mocks base method.
func (m *MockUniversalClient) Set(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// SetArgs mocks base method.
func (m *MockUniversalClient) SetArgs(ctx context.Context, key string, value any, a redis.SetArgs) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetArgs", ctx, key, value, a)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// SetArgs indicates an expected call of SetArgs.
func (mr *MockUniversalClientMockRecorder) SetArgs(ctx, key, value, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockUniversalClient)(nil).SetArgs), ctx, key, value, a)
}

// SetBit mocks base method.
func (m *MockUniversalClient) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBit", ctx, key, offset, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SetBit indicates an expected call of SetBit.
func (mr *MockUniversalClientMockRecorder) SetBit(ctx, key, offset, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockUniversalClient)(nil).SetBit), ctx, key, offset, value)
}

// SetEx mocks base method.
func (m *MockUniversalClient) SetEx(ctx context.Context, key string, value any, expiration time.Duration) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEx", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// SetNX mocks base method.
func (m *MockUniversalClient) SetNX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNX", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// SetRange mocks base method.
func (m *MockUniversalClient) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetRange", ctx, key, offset, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SetRange indicates an expected call of SetRange.
func (mr *MockUniversalClientMockRecorder) SetRange(ctx, key, offset, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockUniversalClient)(nil).SetRange), ctx, key, offset, value)
}

// SetXX mocks base method.
func (m *MockUniversalClient) SetXX(ctx context.Context, key string, value any, expiration time.Duration) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetXX", ctx, key, value, expiration)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

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

// Shutdown mocks base method.
func (m *MockUniversalClient) Shutdown(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Shutdown", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// Shutdown indicates an expected call of Shutdown.
func (mr *MockUniversalClientMockRecorder) Shutdown(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockUniversalClient)(nil).Shutdown), ctx)
}

// ShutdownNoSave mocks base method.
func (m *MockUniversalClient) ShutdownNoSave(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShutdownNoSave", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ShutdownNoSave indicates an expected call of ShutdownNoSave.
func (mr *MockUniversalClientMockRecorder) ShutdownNoSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockUniversalClient)(nil).ShutdownNoSave), ctx)
}

// ShutdownSave mocks base method.
func (m *MockUniversalClient) ShutdownSave(ctx context.Context) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ShutdownSave", ctx)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// ShutdownSave indicates an expected call of ShutdownSave.
func (mr *MockUniversalClientMockRecorder) ShutdownSave(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockUniversalClient)(nil).ShutdownSave), ctx)
}

// SlaveOf mocks base method.
func (m *MockUniversalClient) SlaveOf(ctx context.Context, host, port string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlaveOf", ctx, host, port)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// SlaveOf indicates an expected call of SlaveOf.
func (mr *MockUniversalClientMockRecorder) SlaveOf(ctx, host, port any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockUniversalClient)(nil).SlaveOf), ctx, host, port)
}

// SlowLogGet mocks base method.
func (m *MockUniversalClient) SlowLogGet(ctx context.Context, num int64) *redis.SlowLogCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlowLogGet", ctx, num)
	ret0, _ := ret[0].(*redis.SlowLogCmd)
	return ret0
}

// SlowLogGet indicates an expected call of SlowLogGet.
func (mr *MockUniversalClientMockRecorder) SlowLogGet(ctx, num any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockUniversalClient)(nil).SlowLogGet), ctx, num)
}

// Sort mocks base method.
func (m *MockUniversalClient) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sort", ctx, key, sort)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// Sort indicates an expected call of Sort.
func (mr *MockUniversalClientMockRecorder) Sort(ctx, key, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockUniversalClient)(nil).Sort), ctx, key, sort)
}

// SortInterfaces mocks base method.
func (m *MockUniversalClient) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SortInterfaces", ctx, key, sort)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// SortInterfaces indicates an expected call of SortInterfaces.
func (mr *MockUniversalClientMockRecorder) SortInterfaces(ctx, key, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockUniversalClient)(nil).SortInterfaces), ctx, key, sort)
}

// SortRO mocks base method.
func (m *MockUniversalClient) SortRO(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SortRO", ctx, key, sort)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// SortRO indicates an expected call of SortRO.
func (mr *MockUniversalClientMockRecorder) SortRO(ctx, key, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockUniversalClient)(nil).SortRO), ctx, key, sort)
}

// SortStore mocks base method.
func (m *MockUniversalClient) SortStore(ctx context.Context, key, store string, sort *redis.Sort) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SortStore", ctx, key, store, sort)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// SortStore indicates an expected call of SortStore.
func (mr *MockUniversalClientMockRecorder) SortStore(ctx, key, store, sort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockUniversalClient)(nil).SortStore), ctx, key, store, sort)
}

// StrLen mocks base method.
func (m *MockUniversalClient) StrLen(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StrLen", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// Subscribe mocks base method.
func (m *MockUniversalClient) Subscribe(ctx context.Context, channels ...string) *redis.PubSub {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range channels {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Subscribe", varargs...)
	ret0, _ := ret[0].(*redis.PubSub)
	return ret0
}

// Subscribe indicates an expected call of Subscribe.
func (mr *MockUniversalClientMockRecorder) Subscribe(ctx any, channels ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, channels...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockUniversalClient)(nil).Subscribe), varargs...)
}

// TDigestAdd mocks base method.
func (m *MockUniversalClient) TDigestAdd(ctx context.Context, key string, elements ...float64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestAdd", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TDigestAdd indicates an expected call of TDigestAdd.
func (mr *MockUniversalClientMockRecorder) TDigestAdd(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockUniversalClient)(nil).TDigestAdd), varargs...)
}

// TDigestByRank mocks base method.
func (m *MockUniversalClient) TDigestByRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range rank {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestByRank", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestByRank indicates an expected call of TDigestByRank.
func (mr *MockUniversalClientMockRecorder) TDigestByRank(ctx, key any, rank ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, rank...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestByRank), varargs...)
}

// TDigestByRevRank mocks base method.
func (m *MockUniversalClient) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range rank {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestByRevRank indicates an expected call of TDigestByRevRank.
func (mr *MockUniversalClientMockRecorder) TDigestByRevRank(ctx, key any, rank ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, rank...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestByRevRank), varargs...)
}

// TDigestCDF mocks base method.
func (m *MockUniversalClient) TDigestCDF(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestCDF", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestCDF indicates an expected call of TDigestCDF.
func (mr *MockUniversalClientMockRecorder) TDigestCDF(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCDF), varargs...)
}

// TDigestCreate mocks base method.
func (m *MockUniversalClient) TDigestCreate(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestCreate", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// TDigestCreateWithCompression mocks base method.
func (m *MockUniversalClient) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestCreateWithCompression", ctx, key, compression)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression.
func (mr *MockUniversalClientMockRecorder) TDigestCreateWithCompression(ctx, key, compression any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCreateWithCompression), ctx, key, compression)
}

// TDigestInfo mocks base method.
func (m *MockUniversalClient) TDigestInfo(ctx context.Context, key string) *redis.TDigestInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestInfo", ctx, key)
	ret0, _ := ret[0].(*redis.TDigestInfoCmd)
	return ret0
}

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

// TDigestMax mocks base method.
func (m *MockUniversalClient) TDigestMax(ctx context.Context, key string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestMax", ctx, key)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

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

// TDigestMerge mocks base method.
func (m *MockUniversalClient) TDigestMerge(ctx context.Context, destKey string, options *redis.TDigestMergeOptions, sourceKeys ...string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destKey, options}
	for _, a := range sourceKeys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestMerge", varargs...)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TDigestMerge indicates an expected call of TDigestMerge.
func (mr *MockUniversalClientMockRecorder) TDigestMerge(ctx, destKey, options any, sourceKeys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destKey, options}, sourceKeys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMerge), varargs...)
}

// TDigestMin mocks base method.
func (m *MockUniversalClient) TDigestMin(ctx context.Context, key string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestMin", ctx, key)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

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

// TDigestQuantile mocks base method.
func (m *MockUniversalClient) TDigestQuantile(ctx context.Context, key string, elements ...float64) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestQuantile", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// TDigestQuantile indicates an expected call of TDigestQuantile.
func (mr *MockUniversalClientMockRecorder) TDigestQuantile(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockUniversalClient)(nil).TDigestQuantile), varargs...)
}

// TDigestRank mocks base method.
func (m *MockUniversalClient) TDigestRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestRank", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TDigestRank indicates an expected call of TDigestRank.
func (mr *MockUniversalClientMockRecorder) TDigestRank(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestRank), varargs...)
}

// TDigestReset mocks base method.
func (m *MockUniversalClient) TDigestReset(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestReset", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// TDigestRevRank mocks base method.
func (m *MockUniversalClient) TDigestRevRank(ctx context.Context, key string, values ...float64) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range values {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TDigestRevRank", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TDigestRevRank indicates an expected call of TDigestRevRank.
func (mr *MockUniversalClientMockRecorder) TDigestRevRank(ctx, key any, values ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, values...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestRevRank), varargs...)
}

// TDigestTrimmedMean mocks base method.
func (m *MockUniversalClient) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TDigestTrimmedMean", ctx, key, lowCutQuantile, highCutQuantile)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean.
func (mr *MockUniversalClientMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockUniversalClient)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile)
}

// TSAdd mocks base method.
func (m *MockUniversalClient) TSAdd(ctx context.Context, key string, timestamp any, value float64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSAdd", ctx, key, timestamp, value)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSAdd indicates an expected call of TSAdd.
func (mr *MockUniversalClientMockRecorder) TSAdd(ctx, key, timestamp, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockUniversalClient)(nil).TSAdd), ctx, key, timestamp, value)
}

// TSAddWithArgs mocks base method.
func (m *MockUniversalClient) TSAddWithArgs(ctx context.Context, key string, timestamp any, value float64, options *redis.TSOptions) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSAddWithArgs", ctx, key, timestamp, value, options)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSAddWithArgs indicates an expected call of TSAddWithArgs.
func (mr *MockUniversalClientMockRecorder) TSAddWithArgs(ctx, key, timestamp, value, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSAddWithArgs), ctx, key, timestamp, value, options)
}

// TSAlter mocks base method.
func (m *MockUniversalClient) TSAlter(ctx context.Context, key string, options *redis.TSAlterOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSAlter", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSAlter indicates an expected call of TSAlter.
func (mr *MockUniversalClientMockRecorder) TSAlter(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockUniversalClient)(nil).TSAlter), ctx, key, options)
}

// TSCreate mocks base method.
func (m *MockUniversalClient) TSCreate(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreate", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// TSCreateRule mocks base method.
func (m *MockUniversalClient) TSCreateRule(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreateRule", ctx, sourceKey, destKey, aggregator, bucketDuration)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSCreateRule indicates an expected call of TSCreateRule.
func (mr *MockUniversalClientMockRecorder) TSCreateRule(ctx, sourceKey, destKey, aggregator, bucketDuration any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateRule), ctx, sourceKey, destKey, aggregator, bucketDuration)
}

// TSCreateRuleWithArgs mocks base method.
func (m *MockUniversalClient) TSCreateRuleWithArgs(ctx context.Context, sourceKey, destKey string, aggregator redis.Aggregator, bucketDuration int, options *redis.TSCreateRuleOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", ctx, sourceKey, destKey, aggregator, bucketDuration, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs.
func (mr *MockUniversalClientMockRecorder) TSCreateRuleWithArgs(ctx, sourceKey, destKey, aggregator, bucketDuration, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateRuleWithArgs), ctx, sourceKey, destKey, aggregator, bucketDuration, options)
}

// TSCreateWithArgs mocks base method.
func (m *MockUniversalClient) TSCreateWithArgs(ctx context.Context, key string, options *redis.TSOptions) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSCreateWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSCreateWithArgs indicates an expected call of TSCreateWithArgs.
func (mr *MockUniversalClientMockRecorder) TSCreateWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateWithArgs), ctx, key, options)
}

// TSDecrBy mocks base method.
func (m *MockUniversalClient) TSDecrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDecrBy", ctx, Key, timestamp)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSDecrBy indicates an expected call of TSDecrBy.
func (mr *MockUniversalClientMockRecorder) TSDecrBy(ctx, Key, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockUniversalClient)(nil).TSDecrBy), ctx, Key, timestamp)
}

// TSDecrByWithArgs mocks base method.
func (m *MockUniversalClient) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDecrByWithArgs", ctx, key, timestamp, options)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs.
func (mr *MockUniversalClientMockRecorder) TSDecrByWithArgs(ctx, key, timestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSDecrByWithArgs), ctx, key, timestamp, options)
}

// TSDel mocks base method.
func (m *MockUniversalClient) TSDel(ctx context.Context, Key string, fromTimestamp, toTimestamp int) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDel", ctx, Key, fromTimestamp, toTimestamp)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSDel indicates an expected call of TSDel.
func (mr *MockUniversalClientMockRecorder) TSDel(ctx, Key, fromTimestamp, toTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockUniversalClient)(nil).TSDel), ctx, Key, fromTimestamp, toTimestamp)
}

// TSDeleteRule mocks base method.
func (m *MockUniversalClient) TSDeleteRule(ctx context.Context, sourceKey, destKey string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSDeleteRule", ctx, sourceKey, destKey)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TSDeleteRule indicates an expected call of TSDeleteRule.
func (mr *MockUniversalClientMockRecorder) TSDeleteRule(ctx, sourceKey, destKey any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockUniversalClient)(nil).TSDeleteRule), ctx, sourceKey, destKey)
}

// TSGet mocks base method.
func (m *MockUniversalClient) TSGet(ctx context.Context, key string) *redis.TSTimestampValueCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSGet", ctx, key)
	ret0, _ := ret[0].(*redis.TSTimestampValueCmd)
	return ret0
}

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

// TSGetWithArgs mocks base method.
func (m *MockUniversalClient) TSGetWithArgs(ctx context.Context, key string, options *redis.TSGetOptions) *redis.TSTimestampValueCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSGetWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.TSTimestampValueCmd)
	return ret0
}

// TSGetWithArgs indicates an expected call of TSGetWithArgs.
func (mr *MockUniversalClientMockRecorder) TSGetWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSGetWithArgs), ctx, key, options)
}

// TSIncrBy mocks base method.
func (m *MockUniversalClient) TSIncrBy(ctx context.Context, Key string, timestamp float64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSIncrBy", ctx, Key, timestamp)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSIncrBy indicates an expected call of TSIncrBy.
func (mr *MockUniversalClientMockRecorder) TSIncrBy(ctx, Key, timestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).TSIncrBy), ctx, Key, timestamp)
}

// TSIncrByWithArgs mocks base method.
func (m *MockUniversalClient) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *redis.TSIncrDecrOptions) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSIncrByWithArgs", ctx, key, timestamp, options)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs.
func (mr *MockUniversalClientMockRecorder) TSIncrByWithArgs(ctx, key, timestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSIncrByWithArgs), ctx, key, timestamp, options)
}

// TSInfo mocks base method.
func (m *MockUniversalClient) TSInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSInfo", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

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

// TSInfoWithArgs mocks base method.
func (m *MockUniversalClient) TSInfoWithArgs(ctx context.Context, key string, options *redis.TSInfoOptions) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSInfoWithArgs", ctx, key, options)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

// TSInfoWithArgs indicates an expected call of TSInfoWithArgs.
func (mr *MockUniversalClientMockRecorder) TSInfoWithArgs(ctx, key, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSInfoWithArgs), ctx, key, options)
}

// TSMAdd mocks base method.
func (m *MockUniversalClient) TSMAdd(ctx context.Context, ktvSlices [][]any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMAdd", ctx, ktvSlices)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TSMAdd indicates an expected call of TSMAdd.
func (mr *MockUniversalClientMockRecorder) TSMAdd(ctx, ktvSlices any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockUniversalClient)(nil).TSMAdd), ctx, ktvSlices)
}

// TSMGet mocks base method.
func (m *MockUniversalClient) TSMGet(ctx context.Context, filters []string) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMGet", ctx, filters)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMGet indicates an expected call of TSMGet.
func (mr *MockUniversalClientMockRecorder) TSMGet(ctx, filters any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockUniversalClient)(nil).TSMGet), ctx, filters)
}

// TSMGetWithArgs mocks base method.
func (m *MockUniversalClient) TSMGetWithArgs(ctx context.Context, filters []string, options *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMGetWithArgs", ctx, filters, options)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMGetWithArgs indicates an expected call of TSMGetWithArgs.
func (mr *MockUniversalClientMockRecorder) TSMGetWithArgs(ctx, filters, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMGetWithArgs), ctx, filters, options)
}

// TSMRange mocks base method.
func (m *MockUniversalClient) TSMRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRange", ctx, fromTimestamp, toTimestamp, filterExpr)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRange indicates an expected call of TSMRange.
func (mr *MockUniversalClientMockRecorder) TSMRange(ctx, fromTimestamp, toTimestamp, filterExpr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockUniversalClient)(nil).TSMRange), ctx, fromTimestamp, toTimestamp, filterExpr)
}

// TSMRangeWithArgs mocks base method.
func (m *MockUniversalClient) TSMRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs.
func (mr *MockUniversalClientMockRecorder) TSMRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options)
}

// TSMRevRange mocks base method.
func (m *MockUniversalClient) TSMRevRange(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRevRange", ctx, fromTimestamp, toTimestamp, filterExpr)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRevRange indicates an expected call of TSMRevRange.
func (mr *MockUniversalClientMockRecorder) TSMRevRange(ctx, fromTimestamp, toTimestamp, filterExpr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockUniversalClient)(nil).TSMRevRange), ctx, fromTimestamp, toTimestamp, filterExpr)
}

// TSMRevRangeWithArgs mocks base method.
func (m *MockUniversalClient) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp, toTimestamp int, filterExpr []string, options *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", ctx, fromTimestamp, toTimestamp, filterExpr, options)
	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
	return ret0
}

// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs.
func (mr *MockUniversalClientMockRecorder) TSMRevRangeWithArgs(ctx, fromTimestamp, toTimestamp, filterExpr, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMRevRangeWithArgs), ctx, fromTimestamp, toTimestamp, filterExpr, options)
}

// TSQueryIndex mocks base method.
func (m *MockUniversalClient) TSQueryIndex(ctx context.Context, filterExpr []string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSQueryIndex", ctx, filterExpr)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// TSQueryIndex indicates an expected call of TSQueryIndex.
func (mr *MockUniversalClientMockRecorder) TSQueryIndex(ctx, filterExpr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockUniversalClient)(nil).TSQueryIndex), ctx, filterExpr)
}

// TSRange mocks base method.
func (m *MockUniversalClient) TSRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRange", ctx, key, fromTimestamp, toTimestamp)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRange indicates an expected call of TSRange.
func (mr *MockUniversalClientMockRecorder) TSRange(ctx, key, fromTimestamp, toTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockUniversalClient)(nil).TSRange), ctx, key, fromTimestamp, toTimestamp)
}

// TSRangeWithArgs mocks base method.
func (m *MockUniversalClient) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRangeWithArgs indicates an expected call of TSRangeWithArgs.
func (mr *MockUniversalClientMockRecorder) TSRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options)
}

// TSRevRange mocks base method.
func (m *MockUniversalClient) TSRevRange(ctx context.Context, key string, fromTimestamp, toTimestamp int) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRevRange", ctx, key, fromTimestamp, toTimestamp)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRevRange indicates an expected call of TSRevRange.
func (mr *MockUniversalClientMockRecorder) TSRevRange(ctx, key, fromTimestamp, toTimestamp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockUniversalClient)(nil).TSRevRange), ctx, key, fromTimestamp, toTimestamp)
}

// TSRevRangeWithArgs mocks base method.
func (m *MockUniversalClient) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp, toTimestamp int, options *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TSRevRangeWithArgs", ctx, key, fromTimestamp, toTimestamp, options)
	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
	return ret0
}

// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs.
func (mr *MockUniversalClientMockRecorder) TSRevRangeWithArgs(ctx, key, fromTimestamp, toTimestamp, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSRevRangeWithArgs), ctx, key, fromTimestamp, toTimestamp, options)
}

// TTL mocks base method.
func (m *MockUniversalClient) TTL(ctx context.Context, key string) *redis.DurationCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TTL", ctx, key)
	ret0, _ := ret[0].(*redis.DurationCmd)
	return ret0
}

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

// Time mocks base method.
func (m *MockUniversalClient) Time(ctx context.Context) *redis.TimeCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Time", ctx)
	ret0, _ := ret[0].(*redis.TimeCmd)
	return ret0
}

// Time indicates an expected call of Time.
func (mr *MockUniversalClientMockRecorder) Time(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockUniversalClient)(nil).Time), ctx)
}

// TopKAdd mocks base method.
func (m *MockUniversalClient) TopKAdd(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKAdd", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// TopKAdd indicates an expected call of TopKAdd.
func (mr *MockUniversalClientMockRecorder) TopKAdd(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockUniversalClient)(nil).TopKAdd), varargs...)
}

// TopKCount mocks base method.
func (m *MockUniversalClient) TopKCount(ctx context.Context, key string, elements ...any) *redis.IntSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKCount", varargs...)
	ret0, _ := ret[0].(*redis.IntSliceCmd)
	return ret0
}

// TopKCount indicates an expected call of TopKCount.
func (mr *MockUniversalClientMockRecorder) TopKCount(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockUniversalClient)(nil).TopKCount), varargs...)
}

// TopKIncrBy mocks base method.
func (m *MockUniversalClient) TopKIncrBy(ctx context.Context, key string, elements ...any) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKIncrBy", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// TopKIncrBy indicates an expected call of TopKIncrBy.
func (mr *MockUniversalClientMockRecorder) TopKIncrBy(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).TopKIncrBy), varargs...)
}

// TopKInfo mocks base method.
func (m *MockUniversalClient) TopKInfo(ctx context.Context, key string) *redis.TopKInfoCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKInfo", ctx, key)
	ret0, _ := ret[0].(*redis.TopKInfoCmd)
	return ret0
}

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

// TopKList mocks base method.
func (m *MockUniversalClient) TopKList(ctx context.Context, key string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKList", ctx, key)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

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

// TopKListWithCount mocks base method.
func (m *MockUniversalClient) TopKListWithCount(ctx context.Context, key string) *redis.MapStringIntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKListWithCount", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringIntCmd)
	return ret0
}

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

// TopKQuery mocks base method.
func (m *MockUniversalClient) TopKQuery(ctx context.Context, key string, elements ...any) *redis.BoolSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TopKQuery", varargs...)
	ret0, _ := ret[0].(*redis.BoolSliceCmd)
	return ret0
}

// TopKQuery indicates an expected call of TopKQuery.
func (mr *MockUniversalClientMockRecorder) TopKQuery(ctx, key any, elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, elements...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockUniversalClient)(nil).TopKQuery), varargs...)
}

// TopKReserve mocks base method.
func (m *MockUniversalClient) TopKReserve(ctx context.Context, key string, k int64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKReserve", ctx, key, k)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TopKReserve indicates an expected call of TopKReserve.
func (mr *MockUniversalClientMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockUniversalClient)(nil).TopKReserve), ctx, key, k)
}

// TopKReserveWithOptions mocks base method.
func (m *MockUniversalClient) TopKReserveWithOptions(ctx context.Context, key string, k, width, depth int64, decay float64) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TopKReserveWithOptions", ctx, key, k, width, depth, decay)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions.
func (mr *MockUniversalClientMockRecorder) TopKReserveWithOptions(ctx, key, k, width, depth, decay any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockUniversalClient)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay)
}

// Touch mocks base method.
func (m *MockUniversalClient) Touch(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Touch", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Touch indicates an expected call of Touch.
func (mr *MockUniversalClientMockRecorder) Touch(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockUniversalClient)(nil).Touch), varargs...)
}

// TxPipeline mocks base method.
func (m *MockUniversalClient) TxPipeline() redis.Pipeliner {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxPipeline")
	ret0, _ := ret[0].(redis.Pipeliner)
	return ret0
}

// TxPipeline indicates an expected call of TxPipeline.
func (mr *MockUniversalClientMockRecorder) TxPipeline() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockUniversalClient)(nil).TxPipeline))
}

// TxPipelined mocks base method.
func (m *MockUniversalClient) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxPipelined", ctx, fn)
	ret0, _ := ret[0].([]redis.Cmder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TxPipelined indicates an expected call of TxPipelined.
func (mr *MockUniversalClientMockRecorder) TxPipelined(ctx, fn any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockUniversalClient)(nil).TxPipelined), ctx, fn)
}

// Type mocks base method.
func (m *MockUniversalClient) Type(ctx context.Context, key string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type", ctx, key)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

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

// Unlink mocks base method.
func (m *MockUniversalClient) Unlink(ctx context.Context, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Unlink", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// Unlink indicates an expected call of Unlink.
func (mr *MockUniversalClientMockRecorder) Unlink(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockUniversalClient)(nil).Unlink), varargs...)
}

// VAdd mocks base method.
func (m *MockUniversalClient) VAdd(ctx context.Context, key, element string, val redis.Vector) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VAdd", ctx, key, element, val)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VAdd indicates an expected call of VAdd.
func (mr *MockUniversalClientMockRecorder) VAdd(ctx, key, element, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VAdd", reflect.TypeOf((*MockUniversalClient)(nil).VAdd), ctx, key, element, val)
}

// VAddWithArgs mocks base method.
func (m *MockUniversalClient) VAddWithArgs(ctx context.Context, key, element string, val redis.Vector, addArgs *redis.VAddArgs) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VAddWithArgs", ctx, key, element, val, addArgs)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VAddWithArgs indicates an expected call of VAddWithArgs.
func (mr *MockUniversalClientMockRecorder) VAddWithArgs(ctx, key, element, val, addArgs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VAddWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).VAddWithArgs), ctx, key, element, val, addArgs)
}

// VCard mocks base method.
func (m *MockUniversalClient) VCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// VClearAttributes mocks base method.
func (m *MockUniversalClient) VClearAttributes(ctx context.Context, key, element string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VClearAttributes", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VClearAttributes indicates an expected call of VClearAttributes.
func (mr *MockUniversalClientMockRecorder) VClearAttributes(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VClearAttributes", reflect.TypeOf((*MockUniversalClient)(nil).VClearAttributes), ctx, key, element)
}

// VDim mocks base method.
func (m *MockUniversalClient) VDim(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VDim", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// VEmb mocks base method.
func (m *MockUniversalClient) VEmb(ctx context.Context, key, element string, raw bool) *redis.SliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VEmb", ctx, key, element, raw)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// VEmb indicates an expected call of VEmb.
func (mr *MockUniversalClientMockRecorder) VEmb(ctx, key, element, raw any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VEmb", reflect.TypeOf((*MockUniversalClient)(nil).VEmb), ctx, key, element, raw)
}

// VGetAttr mocks base method.
func (m *MockUniversalClient) VGetAttr(ctx context.Context, key, element string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VGetAttr", ctx, key, element)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// VGetAttr indicates an expected call of VGetAttr.
func (mr *MockUniversalClientMockRecorder) VGetAttr(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VGetAttr", reflect.TypeOf((*MockUniversalClient)(nil).VGetAttr), ctx, key, element)
}

// VInfo mocks base method.
func (m *MockUniversalClient) VInfo(ctx context.Context, key string) *redis.MapStringInterfaceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VInfo", ctx, key)
	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
	return ret0
}

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

// VLinks mocks base method.
func (m *MockUniversalClient) VLinks(ctx context.Context, key, element string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VLinks", ctx, key, element)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VLinks indicates an expected call of VLinks.
func (mr *MockUniversalClientMockRecorder) VLinks(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VLinks", reflect.TypeOf((*MockUniversalClient)(nil).VLinks), ctx, key, element)
}

// VLinksWithScores mocks base method.
func (m *MockUniversalClient) VLinksWithScores(ctx context.Context, key, element string) *redis.VectorScoreSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VLinksWithScores", ctx, key, element)
	ret0, _ := ret[0].(*redis.VectorScoreSliceCmd)
	return ret0
}

// VLinksWithScores indicates an expected call of VLinksWithScores.
func (mr *MockUniversalClientMockRecorder) VLinksWithScores(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VLinksWithScores", reflect.TypeOf((*MockUniversalClient)(nil).VLinksWithScores), ctx, key, element)
}

// VRandMember mocks base method.
func (m *MockUniversalClient) VRandMember(ctx context.Context, key string) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRandMember", ctx, key)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

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

// VRandMemberCount mocks base method.
func (m *MockUniversalClient) VRandMemberCount(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRandMemberCount", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VRandMemberCount indicates an expected call of VRandMemberCount.
func (mr *MockUniversalClientMockRecorder) VRandMemberCount(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRandMemberCount", reflect.TypeOf((*MockUniversalClient)(nil).VRandMemberCount), ctx, key, count)
}

// VRem mocks base method.
func (m *MockUniversalClient) VRem(ctx context.Context, key, element string) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VRem", ctx, key, element)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VRem indicates an expected call of VRem.
func (mr *MockUniversalClientMockRecorder) VRem(ctx, key, element any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VRem", reflect.TypeOf((*MockUniversalClient)(nil).VRem), ctx, key, element)
}

// VSetAttr mocks base method.
func (m *MockUniversalClient) VSetAttr(ctx context.Context, key, element string, attr any) *redis.BoolCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSetAttr", ctx, key, element, attr)
	ret0, _ := ret[0].(*redis.BoolCmd)
	return ret0
}

// VSetAttr indicates an expected call of VSetAttr.
func (mr *MockUniversalClientMockRecorder) VSetAttr(ctx, key, element, attr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSetAttr", reflect.TypeOf((*MockUniversalClient)(nil).VSetAttr), ctx, key, element, attr)
}

// VSim mocks base method.
func (m *MockUniversalClient) VSim(ctx context.Context, key string, val redis.Vector) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSim", ctx, key, val)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VSim indicates an expected call of VSim.
func (mr *MockUniversalClientMockRecorder) VSim(ctx, key, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSim", reflect.TypeOf((*MockUniversalClient)(nil).VSim), ctx, key, val)
}

// VSimWithArgs mocks base method.
func (m *MockUniversalClient) VSimWithArgs(ctx context.Context, key string, val redis.Vector, args *redis.VSimArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSimWithArgs", ctx, key, val, args)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// VSimWithArgs indicates an expected call of VSimWithArgs.
func (mr *MockUniversalClientMockRecorder) VSimWithArgs(ctx, key, val, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSimWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).VSimWithArgs), ctx, key, val, args)
}

// VSimWithArgsWithScores mocks base method.
func (m *MockUniversalClient) VSimWithArgsWithScores(ctx context.Context, key string, val redis.Vector, args *redis.VSimArgs) *redis.VectorScoreSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSimWithArgsWithScores", ctx, key, val, args)
	ret0, _ := ret[0].(*redis.VectorScoreSliceCmd)
	return ret0
}

// VSimWithArgsWithScores indicates an expected call of VSimWithArgsWithScores.
func (mr *MockUniversalClientMockRecorder) VSimWithArgsWithScores(ctx, key, val, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSimWithArgsWithScores", reflect.TypeOf((*MockUniversalClient)(nil).VSimWithArgsWithScores), ctx, key, val, args)
}

// VSimWithScores mocks base method.
func (m *MockUniversalClient) VSimWithScores(ctx context.Context, key string, val redis.Vector) *redis.VectorScoreSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VSimWithScores", ctx, key, val)
	ret0, _ := ret[0].(*redis.VectorScoreSliceCmd)
	return ret0
}

// VSimWithScores indicates an expected call of VSimWithScores.
func (mr *MockUniversalClientMockRecorder) VSimWithScores(ctx, key, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VSimWithScores", reflect.TypeOf((*MockUniversalClient)(nil).VSimWithScores), ctx, key, val)
}

// Watch mocks base method.
func (m *MockUniversalClient) Watch(ctx context.Context, fn func(*redis.Tx) error, keys ...string) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, fn}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Watch indicates an expected call of Watch.
func (mr *MockUniversalClientMockRecorder) Watch(ctx, fn any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, fn}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockUniversalClient)(nil).Watch), varargs...)
}

// XAck mocks base method.
func (m *MockUniversalClient) XAck(ctx context.Context, stream, group string, ids ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream, group}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XAck", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XAck indicates an expected call of XAck.
func (mr *MockUniversalClientMockRecorder) XAck(ctx, stream, group any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream, group}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockUniversalClient)(nil).XAck), varargs...)
}

// XAckDel mocks base method.
func (m *MockUniversalClient) XAckDel(ctx context.Context, stream, group, mode string, ids ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream, group, mode}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XAckDel", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// XAckDel indicates an expected call of XAckDel.
func (mr *MockUniversalClientMockRecorder) XAckDel(ctx, stream, group, mode any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream, group, mode}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAckDel", reflect.TypeOf((*MockUniversalClient)(nil).XAckDel), varargs...)
}

// XAdd mocks base method.
func (m *MockUniversalClient) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XAdd", ctx, a)
	ret0, _ := ret[0].(*redis.StringCmd)
	return ret0
}

// XAdd indicates an expected call of XAdd.
func (mr *MockUniversalClientMockRecorder) XAdd(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockUniversalClient)(nil).XAdd), ctx, a)
}

// XAutoClaim mocks base method.
func (m *MockUniversalClient) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XAutoClaim", ctx, a)
	ret0, _ := ret[0].(*redis.XAutoClaimCmd)
	return ret0
}

// XAutoClaim indicates an expected call of XAutoClaim.
func (mr *MockUniversalClientMockRecorder) XAutoClaim(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockUniversalClient)(nil).XAutoClaim), ctx, a)
}

// XAutoClaimJustID mocks base method.
func (m *MockUniversalClient) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XAutoClaimJustID", ctx, a)
	ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd)
	return ret0
}

// XAutoClaimJustID indicates an expected call of XAutoClaimJustID.
func (mr *MockUniversalClientMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockUniversalClient)(nil).XAutoClaimJustID), ctx, a)
}

// XClaim mocks base method.
func (m *MockUniversalClient) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XClaim", ctx, a)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XClaim indicates an expected call of XClaim.
func (mr *MockUniversalClientMockRecorder) XClaim(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockUniversalClient)(nil).XClaim), ctx, a)
}

// XClaimJustID mocks base method.
func (m *MockUniversalClient) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XClaimJustID", ctx, a)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// XClaimJustID indicates an expected call of XClaimJustID.
func (mr *MockUniversalClientMockRecorder) XClaimJustID(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockUniversalClient)(nil).XClaimJustID), ctx, a)
}

// XDel mocks base method.
func (m *MockUniversalClient) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XDel", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XDel indicates an expected call of XDel.
func (mr *MockUniversalClientMockRecorder) XDel(ctx, stream any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockUniversalClient)(nil).XDel), varargs...)
}

// XDelEx mocks base method.
func (m *MockUniversalClient) XDelEx(ctx context.Context, stream, mode string, ids ...string) *redis.SliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, stream, mode}
	for _, a := range ids {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XDelEx", varargs...)
	ret0, _ := ret[0].(*redis.SliceCmd)
	return ret0
}

// XDelEx indicates an expected call of XDelEx.
func (mr *MockUniversalClientMockRecorder) XDelEx(ctx, stream, mode any, ids ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, stream, mode}, ids...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDelEx", reflect.TypeOf((*MockUniversalClient)(nil).XDelEx), varargs...)
}

// XGroupCreate mocks base method.
func (m *MockUniversalClient) XGroupCreate(ctx context.Context, stream, group, start string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupCreate", ctx, stream, group, start)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// XGroupCreate indicates an expected call of XGroupCreate.
func (mr *MockUniversalClientMockRecorder) XGroupCreate(ctx, stream, group, start any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreate), ctx, stream, group, start)
}

// XGroupCreateConsumer mocks base method.
func (m *MockUniversalClient) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupCreateConsumer", ctx, stream, group, consumer)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer.
func (mr *MockUniversalClientMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreateConsumer), ctx, stream, group, consumer)
}

// XGroupCreateMkStream mocks base method.
func (m *MockUniversalClient) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupCreateMkStream", ctx, stream, group, start)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream.
func (mr *MockUniversalClientMockRecorder) XGroupCreateMkStream(ctx, stream, group, start any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreateMkStream), ctx, stream, group, start)
}

// XGroupDelConsumer mocks base method.
func (m *MockUniversalClient) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupDelConsumer", ctx, stream, group, consumer)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XGroupDelConsumer indicates an expected call of XGroupDelConsumer.
func (mr *MockUniversalClientMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockUniversalClient)(nil).XGroupDelConsumer), ctx, stream, group, consumer)
}

// XGroupDestroy mocks base method.
func (m *MockUniversalClient) XGroupDestroy(ctx context.Context, stream, group string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupDestroy", ctx, stream, group)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XGroupDestroy indicates an expected call of XGroupDestroy.
func (mr *MockUniversalClientMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockUniversalClient)(nil).XGroupDestroy), ctx, stream, group)
}

// XGroupSetID mocks base method.
func (m *MockUniversalClient) XGroupSetID(ctx context.Context, stream, group, start string) *redis.StatusCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XGroupSetID", ctx, stream, group, start)
	ret0, _ := ret[0].(*redis.StatusCmd)
	return ret0
}

// XGroupSetID indicates an expected call of XGroupSetID.
func (mr *MockUniversalClientMockRecorder) XGroupSetID(ctx, stream, group, start any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockUniversalClient)(nil).XGroupSetID), ctx, stream, group, start)
}

// XInfoConsumers mocks base method.
func (m *MockUniversalClient) XInfoConsumers(ctx context.Context, key, group string) *redis.XInfoConsumersCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoConsumers", ctx, key, group)
	ret0, _ := ret[0].(*redis.XInfoConsumersCmd)
	return ret0
}

// XInfoConsumers indicates an expected call of XInfoConsumers.
func (mr *MockUniversalClientMockRecorder) XInfoConsumers(ctx, key, group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockUniversalClient)(nil).XInfoConsumers), ctx, key, group)
}

// XInfoGroups mocks base method.
func (m *MockUniversalClient) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoGroups", ctx, key)
	ret0, _ := ret[0].(*redis.XInfoGroupsCmd)
	return ret0
}

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

// XInfoStream mocks base method.
func (m *MockUniversalClient) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoStream", ctx, key)
	ret0, _ := ret[0].(*redis.XInfoStreamCmd)
	return ret0
}

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

// XInfoStreamFull mocks base method.
func (m *MockUniversalClient) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XInfoStreamFull", ctx, key, count)
	ret0, _ := ret[0].(*redis.XInfoStreamFullCmd)
	return ret0
}

// XInfoStreamFull indicates an expected call of XInfoStreamFull.
func (mr *MockUniversalClientMockRecorder) XInfoStreamFull(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockUniversalClient)(nil).XInfoStreamFull), ctx, key, count)
}

// XLen mocks base method.
func (m *MockUniversalClient) XLen(ctx context.Context, stream string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XLen", ctx, stream)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XLen indicates an expected call of XLen.
func (mr *MockUniversalClientMockRecorder) XLen(ctx, stream any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockUniversalClient)(nil).XLen), ctx, stream)
}

// XPending mocks base method.
func (m *MockUniversalClient) XPending(ctx context.Context, stream, group string) *redis.XPendingCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XPending", ctx, stream, group)
	ret0, _ := ret[0].(*redis.XPendingCmd)
	return ret0
}

// XPending indicates an expected call of XPending.
func (mr *MockUniversalClientMockRecorder) XPending(ctx, stream, group any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockUniversalClient)(nil).XPending), ctx, stream, group)
}

// XPendingExt mocks base method.
func (m *MockUniversalClient) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XPendingExt", ctx, a)
	ret0, _ := ret[0].(*redis.XPendingExtCmd)
	return ret0
}

// XPendingExt indicates an expected call of XPendingExt.
func (mr *MockUniversalClientMockRecorder) XPendingExt(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockUniversalClient)(nil).XPendingExt), ctx, a)
}

// XRange mocks base method.
func (m *MockUniversalClient) XRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRange", ctx, stream, start, stop)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRange indicates an expected call of XRange.
func (mr *MockUniversalClientMockRecorder) XRange(ctx, stream, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockUniversalClient)(nil).XRange), ctx, stream, start, stop)
}

// XRangeN mocks base method.
func (m *MockUniversalClient) XRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRangeN", ctx, stream, start, stop, count)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRangeN indicates an expected call of XRangeN.
func (mr *MockUniversalClientMockRecorder) XRangeN(ctx, stream, start, stop, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockUniversalClient)(nil).XRangeN), ctx, stream, start, stop, count)
}

// XRead mocks base method.
func (m *MockUniversalClient) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRead", ctx, a)
	ret0, _ := ret[0].(*redis.XStreamSliceCmd)
	return ret0
}

// XRead indicates an expected call of XRead.
func (mr *MockUniversalClientMockRecorder) XRead(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockUniversalClient)(nil).XRead), ctx, a)
}

// XReadGroup mocks base method.
func (m *MockUniversalClient) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XReadGroup", ctx, a)
	ret0, _ := ret[0].(*redis.XStreamSliceCmd)
	return ret0
}

// XReadGroup indicates an expected call of XReadGroup.
func (mr *MockUniversalClientMockRecorder) XReadGroup(ctx, a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockUniversalClient)(nil).XReadGroup), ctx, a)
}

// XReadStreams mocks base method.
func (m *MockUniversalClient) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range streams {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "XReadStreams", varargs...)
	ret0, _ := ret[0].(*redis.XStreamSliceCmd)
	return ret0
}

// XReadStreams indicates an expected call of XReadStreams.
func (mr *MockUniversalClientMockRecorder) XReadStreams(ctx any, streams ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, streams...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockUniversalClient)(nil).XReadStreams), varargs...)
}

// XRevRange mocks base method.
func (m *MockUniversalClient) XRevRange(ctx context.Context, stream, start, stop string) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRevRange", ctx, stream, start, stop)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRevRange indicates an expected call of XRevRange.
func (mr *MockUniversalClientMockRecorder) XRevRange(ctx, stream, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockUniversalClient)(nil).XRevRange), ctx, stream, start, stop)
}

// XRevRangeN mocks base method.
func (m *MockUniversalClient) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *redis.XMessageSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XRevRangeN", ctx, stream, start, stop, count)
	ret0, _ := ret[0].(*redis.XMessageSliceCmd)
	return ret0
}

// XRevRangeN indicates an expected call of XRevRangeN.
func (mr *MockUniversalClientMockRecorder) XRevRangeN(ctx, stream, start, stop, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockUniversalClient)(nil).XRevRangeN), ctx, stream, start, stop, count)
}

// XTrimMaxLen mocks base method.
func (m *MockUniversalClient) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLen", ctx, key, maxLen)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLen indicates an expected call of XTrimMaxLen.
func (mr *MockUniversalClientMockRecorder) XTrimMaxLen(ctx, key, maxLen any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLen), ctx, key, maxLen)
}

// XTrimMaxLenApprox mocks base method.
func (m *MockUniversalClient) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLenApprox", ctx, key, maxLen, limit)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox.
func (mr *MockUniversalClientMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit)
}

// XTrimMaxLenApproxMode mocks base method.
func (m *MockUniversalClient) XTrimMaxLenApproxMode(ctx context.Context, key string, maxLen, limit int64, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLenApproxMode", ctx, key, maxLen, limit, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLenApproxMode indicates an expected call of XTrimMaxLenApproxMode.
func (mr *MockUniversalClientMockRecorder) XTrimMaxLenApproxMode(ctx, key, maxLen, limit, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApproxMode", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLenApproxMode), ctx, key, maxLen, limit, mode)
}

// XTrimMaxLenMode mocks base method.
func (m *MockUniversalClient) XTrimMaxLenMode(ctx context.Context, key string, maxLen int64, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMaxLenMode", ctx, key, maxLen, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMaxLenMode indicates an expected call of XTrimMaxLenMode.
func (mr *MockUniversalClientMockRecorder) XTrimMaxLenMode(ctx, key, maxLen, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenMode", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLenMode), ctx, key, maxLen, mode)
}

// XTrimMinID mocks base method.
func (m *MockUniversalClient) XTrimMinID(ctx context.Context, key, minID string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinID", ctx, key, minID)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinID indicates an expected call of XTrimMinID.
func (mr *MockUniversalClientMockRecorder) XTrimMinID(ctx, key, minID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinID), ctx, key, minID)
}

// XTrimMinIDApprox mocks base method.
func (m *MockUniversalClient) XTrimMinIDApprox(ctx context.Context, key, minID string, limit int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinIDApprox", ctx, key, minID, limit)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox.
func (mr *MockUniversalClientMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinIDApprox), ctx, key, minID, limit)
}

// XTrimMinIDApproxMode mocks base method.
func (m *MockUniversalClient) XTrimMinIDApproxMode(ctx context.Context, key, minID string, limit int64, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinIDApproxMode", ctx, key, minID, limit, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinIDApproxMode indicates an expected call of XTrimMinIDApproxMode.
func (mr *MockUniversalClientMockRecorder) XTrimMinIDApproxMode(ctx, key, minID, limit, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApproxMode", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinIDApproxMode), ctx, key, minID, limit, mode)
}

// XTrimMinIDMode mocks base method.
func (m *MockUniversalClient) XTrimMinIDMode(ctx context.Context, key, minID, mode string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "XTrimMinIDMode", ctx, key, minID, mode)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// XTrimMinIDMode indicates an expected call of XTrimMinIDMode.
func (mr *MockUniversalClientMockRecorder) XTrimMinIDMode(ctx, key, minID, mode any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDMode", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinIDMode), ctx, key, minID, mode)
}

// ZAdd mocks base method.
func (m *MockUniversalClient) ZAdd(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAdd", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAdd indicates an expected call of ZAdd.
func (mr *MockUniversalClientMockRecorder) ZAdd(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockUniversalClient)(nil).ZAdd), varargs...)
}

// ZAddArgs mocks base method.
func (m *MockUniversalClient) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZAddArgs", ctx, key, args)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddArgs indicates an expected call of ZAddArgs.
func (mr *MockUniversalClientMockRecorder) ZAddArgs(ctx, key, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockUniversalClient)(nil).ZAddArgs), ctx, key, args)
}

// ZAddArgsIncr mocks base method.
func (m *MockUniversalClient) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZAddArgsIncr", ctx, key, args)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// ZAddArgsIncr indicates an expected call of ZAddArgsIncr.
func (mr *MockUniversalClientMockRecorder) ZAddArgsIncr(ctx, key, args any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockUniversalClient)(nil).ZAddArgsIncr), ctx, key, args)
}

// ZAddGT mocks base method.
func (m *MockUniversalClient) ZAddGT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddGT", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddGT indicates an expected call of ZAddGT.
func (mr *MockUniversalClientMockRecorder) ZAddGT(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockUniversalClient)(nil).ZAddGT), varargs...)
}

// ZAddLT mocks base method.
func (m *MockUniversalClient) ZAddLT(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddLT", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddLT indicates an expected call of ZAddLT.
func (mr *MockUniversalClientMockRecorder) ZAddLT(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockUniversalClient)(nil).ZAddLT), varargs...)
}

// ZAddNX mocks base method.
func (m *MockUniversalClient) ZAddNX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddNX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddNX indicates an expected call of ZAddNX.
func (mr *MockUniversalClientMockRecorder) ZAddNX(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockUniversalClient)(nil).ZAddNX), varargs...)
}

// ZAddXX mocks base method.
func (m *MockUniversalClient) ZAddXX(ctx context.Context, key string, members ...redis.Z) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZAddXX", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZAddXX indicates an expected call of ZAddXX.
func (mr *MockUniversalClientMockRecorder) ZAddXX(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockUniversalClient)(nil).ZAddXX), varargs...)
}

// ZCard mocks base method.
func (m *MockUniversalClient) ZCard(ctx context.Context, key string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZCard", ctx, key)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

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

// ZCount mocks base method.
func (m *MockUniversalClient) ZCount(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZCount", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZCount indicates an expected call of ZCount.
func (mr *MockUniversalClientMockRecorder) ZCount(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockUniversalClient)(nil).ZCount), ctx, key, min, max)
}

// ZDiff mocks base method.
func (m *MockUniversalClient) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZDiff", varargs...)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZDiff indicates an expected call of ZDiff.
func (mr *MockUniversalClientMockRecorder) ZDiff(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockUniversalClient)(nil).ZDiff), varargs...)
}

// ZDiffStore mocks base method.
func (m *MockUniversalClient) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, destination}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZDiffStore", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZDiffStore indicates an expected call of ZDiffStore.
func (mr *MockUniversalClientMockRecorder) ZDiffStore(ctx, destination any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, destination}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockUniversalClient)(nil).ZDiffStore), varargs...)
}

// ZDiffWithScores mocks base method.
func (m *MockUniversalClient) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZDiffWithScores indicates an expected call of ZDiffWithScores.
func (mr *MockUniversalClientMockRecorder) ZDiffWithScores(ctx any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZDiffWithScores), varargs...)
}

// ZIncrBy mocks base method.
func (m *MockUniversalClient) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZIncrBy", ctx, key, increment, member)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// ZIncrBy indicates an expected call of ZIncrBy.
func (mr *MockUniversalClientMockRecorder) ZIncrBy(ctx, key, increment, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).ZIncrBy), ctx, key, increment, member)
}

// ZInter mocks base method.
func (m *MockUniversalClient) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZInter", ctx, store)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZInter indicates an expected call of ZInter.
func (mr *MockUniversalClientMockRecorder) ZInter(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockUniversalClient)(nil).ZInter), ctx, store)
}

// ZInterCard mocks base method.
func (m *MockUniversalClient) ZInterCard(ctx context.Context, limit int64, keys ...string) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, limit}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZInterCard", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZInterCard indicates an expected call of ZInterCard.
func (mr *MockUniversalClientMockRecorder) ZInterCard(ctx, limit any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, limit}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockUniversalClient)(nil).ZInterCard), varargs...)
}

// ZInterStore mocks base method.
func (m *MockUniversalClient) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZInterStore", ctx, destination, store)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZInterStore indicates an expected call of ZInterStore.
func (mr *MockUniversalClientMockRecorder) ZInterStore(ctx, destination, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockUniversalClient)(nil).ZInterStore), ctx, destination, store)
}

// ZInterWithScores mocks base method.
func (m *MockUniversalClient) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZInterWithScores", ctx, store)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZInterWithScores indicates an expected call of ZInterWithScores.
func (mr *MockUniversalClientMockRecorder) ZInterWithScores(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZInterWithScores), ctx, store)
}

// ZLexCount mocks base method.
func (m *MockUniversalClient) ZLexCount(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZLexCount", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZLexCount indicates an expected call of ZLexCount.
func (mr *MockUniversalClientMockRecorder) ZLexCount(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockUniversalClient)(nil).ZLexCount), ctx, key, min, max)
}

// ZMPop mocks base method.
func (m *MockUniversalClient) ZMPop(ctx context.Context, order string, count int64, keys ...string) *redis.ZSliceWithKeyCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, order, count}
	for _, a := range keys {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZMPop", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd)
	return ret0
}

// ZMPop indicates an expected call of ZMPop.
func (mr *MockUniversalClientMockRecorder) ZMPop(ctx, order, count any, keys ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, order, count}, keys...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockUniversalClient)(nil).ZMPop), varargs...)
}

// ZMScore mocks base method.
func (m *MockUniversalClient) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZMScore", varargs...)
	ret0, _ := ret[0].(*redis.FloatSliceCmd)
	return ret0
}

// ZMScore indicates an expected call of ZMScore.
func (mr *MockUniversalClientMockRecorder) ZMScore(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockUniversalClient)(nil).ZMScore), varargs...)
}

// ZPopMax mocks base method.
func (m *MockUniversalClient) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range count {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZPopMax", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZPopMax indicates an expected call of ZPopMax.
func (mr *MockUniversalClientMockRecorder) ZPopMax(ctx, key any, count ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, count...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockUniversalClient)(nil).ZPopMax), varargs...)
}

// ZPopMin mocks base method.
func (m *MockUniversalClient) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range count {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZPopMin", varargs...)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZPopMin indicates an expected call of ZPopMin.
func (mr *MockUniversalClientMockRecorder) ZPopMin(ctx, key any, count ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, count...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockUniversalClient)(nil).ZPopMin), varargs...)
}

// ZRandMember mocks base method.
func (m *MockUniversalClient) ZRandMember(ctx context.Context, key string, count int) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRandMember", ctx, key, count)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRandMember indicates an expected call of ZRandMember.
func (mr *MockUniversalClientMockRecorder) ZRandMember(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockUniversalClient)(nil).ZRandMember), ctx, key, count)
}

// ZRandMemberWithScores mocks base method.
func (m *MockUniversalClient) ZRandMemberWithScores(ctx context.Context, key string, count int) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRandMemberWithScores", ctx, key, count)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores.
func (mr *MockUniversalClientMockRecorder) ZRandMemberWithScores(ctx, key, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRandMemberWithScores), ctx, key, count)
}

// ZRange mocks base method.
func (m *MockUniversalClient) ZRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRange", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRange indicates an expected call of ZRange.
func (mr *MockUniversalClientMockRecorder) ZRange(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockUniversalClient)(nil).ZRange), ctx, key, start, stop)
}

// ZRangeArgs mocks base method.
func (m *MockUniversalClient) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeArgs", ctx, z)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRangeArgs indicates an expected call of ZRangeArgs.
func (mr *MockUniversalClientMockRecorder) ZRangeArgs(ctx, z any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeArgs), ctx, z)
}

// ZRangeArgsWithScores mocks base method.
func (m *MockUniversalClient) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeArgsWithScores", ctx, z)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores.
func (mr *MockUniversalClientMockRecorder) ZRangeArgsWithScores(ctx, z any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeArgsWithScores), ctx, z)
}

// ZRangeByLex mocks base method.
func (m *MockUniversalClient) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeByLex", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRangeByLex indicates an expected call of ZRangeByLex.
func (mr *MockUniversalClientMockRecorder) ZRangeByLex(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByLex), ctx, key, opt)
}

// ZRangeByScore mocks base method.
func (m *MockUniversalClient) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeByScore", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRangeByScore indicates an expected call of ZRangeByScore.
func (mr *MockUniversalClientMockRecorder) ZRangeByScore(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByScore), ctx, key, opt)
}

// ZRangeByScoreWithScores mocks base method.
func (m *MockUniversalClient) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", ctx, key, opt)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores.
func (mr *MockUniversalClientMockRecorder) ZRangeByScoreWithScores(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByScoreWithScores), ctx, key, opt)
}

// ZRangeStore mocks base method.
func (m *MockUniversalClient) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeStore", ctx, dst, z)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRangeStore indicates an expected call of ZRangeStore.
func (mr *MockUniversalClientMockRecorder) ZRangeStore(ctx, dst, z any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeStore), ctx, dst, z)
}

// ZRangeWithScores mocks base method.
func (m *MockUniversalClient) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRangeWithScores", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRangeWithScores indicates an expected call of ZRangeWithScores.
func (mr *MockUniversalClientMockRecorder) ZRangeWithScores(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeWithScores), ctx, key, start, stop)
}

// ZRank mocks base method.
func (m *MockUniversalClient) ZRank(ctx context.Context, key, member string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRank", ctx, key, member)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRank indicates an expected call of ZRank.
func (mr *MockUniversalClientMockRecorder) ZRank(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRank), ctx, key, member)
}

// ZRankWithScore mocks base method.
func (m *MockUniversalClient) ZRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRankWithScore", ctx, key, member)
	ret0, _ := ret[0].(*redis.RankWithScoreCmd)
	return ret0
}

// ZRankWithScore indicates an expected call of ZRankWithScore.
func (mr *MockUniversalClientMockRecorder) ZRankWithScore(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRankWithScore), ctx, key, member)
}

// ZRem mocks base method.
func (m *MockUniversalClient) ZRem(ctx context.Context, key string, members ...any) *redis.IntCmd {
	m.ctrl.T.Helper()
	varargs := []any{ctx, key}
	for _, a := range members {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ZRem", varargs...)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRem indicates an expected call of ZRem.
func (mr *MockUniversalClientMockRecorder) ZRem(ctx, key any, members ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, key}, members...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockUniversalClient)(nil).ZRem), varargs...)
}

// ZRemRangeByLex mocks base method.
func (m *MockUniversalClient) ZRemRangeByLex(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRemRangeByLex", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRemRangeByLex indicates an expected call of ZRemRangeByLex.
func (mr *MockUniversalClientMockRecorder) ZRemRangeByLex(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByLex), ctx, key, min, max)
}

// ZRemRangeByRank mocks base method.
func (m *MockUniversalClient) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRemRangeByRank", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRemRangeByRank indicates an expected call of ZRemRangeByRank.
func (mr *MockUniversalClientMockRecorder) ZRemRangeByRank(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByRank), ctx, key, start, stop)
}

// ZRemRangeByScore mocks base method.
func (m *MockUniversalClient) ZRemRangeByScore(ctx context.Context, key, min, max string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRemRangeByScore", ctx, key, min, max)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRemRangeByScore indicates an expected call of ZRemRangeByScore.
func (mr *MockUniversalClientMockRecorder) ZRemRangeByScore(ctx, key, min, max any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByScore), ctx, key, min, max)
}

// ZRevRange mocks base method.
func (m *MockUniversalClient) ZRevRange(ctx context.Context, key string, start, stop int64) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRange", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRevRange indicates an expected call of ZRevRange.
func (mr *MockUniversalClientMockRecorder) ZRevRange(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRange), ctx, key, start, stop)
}

// ZRevRangeByLex mocks base method.
func (m *MockUniversalClient) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeByLex", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRevRangeByLex indicates an expected call of ZRevRangeByLex.
func (mr *MockUniversalClientMockRecorder) ZRevRangeByLex(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByLex), ctx, key, opt)
}

// ZRevRangeByScore mocks base method.
func (m *MockUniversalClient) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeByScore", ctx, key, opt)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZRevRangeByScore indicates an expected call of ZRevRangeByScore.
func (mr *MockUniversalClientMockRecorder) ZRevRangeByScore(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByScore), ctx, key, opt)
}

// ZRevRangeByScoreWithScores mocks base method.
func (m *MockUniversalClient) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", ctx, key, opt)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores.
func (mr *MockUniversalClientMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByScoreWithScores), ctx, key, opt)
}

// ZRevRangeWithScores mocks base method.
func (m *MockUniversalClient) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRangeWithScores", ctx, key, start, stop)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores.
func (mr *MockUniversalClientMockRecorder) ZRevRangeWithScores(ctx, key, start, stop any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeWithScores), ctx, key, start, stop)
}

// ZRevRank mocks base method.
func (m *MockUniversalClient) ZRevRank(ctx context.Context, key, member string) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRank", ctx, key, member)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZRevRank indicates an expected call of ZRevRank.
func (mr *MockUniversalClientMockRecorder) ZRevRank(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRank), ctx, key, member)
}

// ZRevRankWithScore mocks base method.
func (m *MockUniversalClient) ZRevRankWithScore(ctx context.Context, key, member string) *redis.RankWithScoreCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZRevRankWithScore", ctx, key, member)
	ret0, _ := ret[0].(*redis.RankWithScoreCmd)
	return ret0
}

// ZRevRankWithScore indicates an expected call of ZRevRankWithScore.
func (mr *MockUniversalClientMockRecorder) ZRevRankWithScore(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRankWithScore), ctx, key, member)
}

// ZScan mocks base method.
func (m *MockUniversalClient) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZScan", ctx, key, cursor, match, count)
	ret0, _ := ret[0].(*redis.ScanCmd)
	return ret0
}

// ZScan indicates an expected call of ZScan.
func (mr *MockUniversalClientMockRecorder) ZScan(ctx, key, cursor, match, count any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockUniversalClient)(nil).ZScan), ctx, key, cursor, match, count)
}

// ZScore mocks base method.
func (m *MockUniversalClient) ZScore(ctx context.Context, key, member string) *redis.FloatCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZScore", ctx, key, member)
	ret0, _ := ret[0].(*redis.FloatCmd)
	return ret0
}

// ZScore indicates an expected call of ZScore.
func (mr *MockUniversalClientMockRecorder) ZScore(ctx, key, member any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockUniversalClient)(nil).ZScore), ctx, key, member)
}

// ZUnion mocks base method.
func (m *MockUniversalClient) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZUnion", ctx, store)
	ret0, _ := ret[0].(*redis.StringSliceCmd)
	return ret0
}

// ZUnion indicates an expected call of ZUnion.
func (mr *MockUniversalClientMockRecorder) ZUnion(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockUniversalClient)(nil).ZUnion), ctx, store)
}

// ZUnionStore mocks base method.
func (m *MockUniversalClient) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZUnionStore", ctx, dest, store)
	ret0, _ := ret[0].(*redis.IntCmd)
	return ret0
}

// ZUnionStore indicates an expected call of ZUnionStore.
func (mr *MockUniversalClientMockRecorder) ZUnionStore(ctx, dest, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockUniversalClient)(nil).ZUnionStore), ctx, dest, store)
}

// ZUnionWithScores mocks base method.
func (m *MockUniversalClient) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ZUnionWithScores", ctx, store)
	ret0, _ := ret[0].(*redis.ZSliceCmd)
	return ret0
}

// ZUnionWithScores indicates an expected call of ZUnionWithScores.
func (mr *MockUniversalClientMockRecorder) ZUnionWithScores(ctx, store any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZUnionWithScores), ctx, store)
}
