diff --git a/go.mod b/go.mod index 379257d..b71504a 100644 --- a/go.mod +++ b/go.mod @@ -6,6 +6,7 @@ require ( github.com/gin-gonic/gin v1.9.1 github.com/redis/go-redis/v9 v9.1.0 github.com/stretchr/testify v1.8.3 + go.uber.org/atomic v1.11.0 go.uber.org/mock v0.3.0 ) @@ -33,9 +34,11 @@ require ( github.com/ugorji/go/codec v1.2.11 // indirect golang.org/x/arch v0.3.0 // indirect golang.org/x/crypto v0.9.0 // indirect + golang.org/x/mod v0.11.0 // indirect golang.org/x/net v0.10.0 // indirect golang.org/x/sys v0.8.0 // indirect golang.org/x/text v0.9.0 // indirect + golang.org/x/tools v0.6.0 // indirect google.golang.org/protobuf v1.30.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 6376821..abed3fd 100644 --- a/go.sum +++ b/go.sum @@ -70,6 +70,8 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08= github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU= github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg= +go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= +go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0= go.uber.org/mock v0.3.0 h1:3mUxI1No2/60yUYax92Pt8eNOEecx2D3lcXZh2NEZJo= go.uber.org/mock v0.3.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= @@ -77,6 +79,8 @@ golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k= golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8= golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g= golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= +golang.org/x/mod v0.11.0 h1:bUO06HqtnRcc/7l71XBe4WcqTZ+3AH1J59zWDDwLKgU= +golang.org/x/mod v0.11.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -85,6 +89,8 @@ golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= +golang.org/x/tools v0.6.0 h1:BOw41kyTf3PuCW1pVQf8+Cyg8pMlkYB1oo9iJ6D/lKM= +golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw= diff --git a/internal/integration/activelimit_test.go b/internal/integration/activelimit_test.go new file mode 100644 index 0000000..3edf207 --- /dev/null +++ b/internal/integration/activelimit_test.go @@ -0,0 +1,173 @@ +//go:build e2e + +package integration + +import ( + "context" + "fmt" + "github.com/ecodeclub/ginx/middlewares/activelimit/redislimit" + "github.com/redis/go-redis/v9" + "net/http" + "net/http/httptest" + "testing" + "time" + + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestBuilder_e2e_ActiveRedisLimit(t *testing.T) { + redisClient := redis.NewClient(&redis.Options{ + Addr: "localhost:16379", + Password: "", + DB: 0, + }) + ctx, cancel := context.WithTimeout(context.Background(), time.Second*3) + defer cancel() + err := redisClient.Ping(ctx).Err() + if err != nil { + panic("redislimit 连接失败") + } + defer func() { + _ = redisClient.Close() + }() + + testCases := []struct { + name string + maxCount int64 + key string + getReq func() *http.Request + createMiddleware func(maxActive int64, key string) gin.HandlerFunc + before func(server *gin.Engine, key string) + + interval time.Duration + after func(string2 string) (int64, error) + + //响应的code + wantCode int + + //检查退出的时候redis 状态 + afterCount int64 + afterErr error + }{ + { + name: "开启限流,RedisLimit正常操作", + + createMiddleware: func(maxActive int64, key string) gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, maxActive, key).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + interval: time.Millisecond * 10, + after: func(key string) (int64, error) { + + return redisClient.Get(context.Background(), key).Int64() + }, + + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + + afterCount: 0, + afterErr: nil, + }, + { + name: "开启限流,RedisLimit,有一个人长时间没退出,导致限流", + + createMiddleware: func(maxActive int64, key string) gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, maxActive, key).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + + interval: time.Millisecond * 50, + after: func(key string) (int64, error) { + + return redisClient.Get(context.Background(), key).Int64() + }, + maxCount: 1, + key: "test", + wantCode: http.StatusTooManyRequests, + afterCount: 1, + afterErr: nil, + }, + { + name: "开启限流,RedisLimit,有一个人长时间没退出,等待前面退出后,正常请求....", + + createMiddleware: func(maxActive int64, key string) gin.HandlerFunc { + return redislimit.NewRedisActiveLimit(redisClient, maxActive, key).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + interval: time.Millisecond * 200, + after: func(key string) (int64, error) { + + return redisClient.Get(context.Background(), key).Int64() + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + afterCount: 0, + afterErr: nil, + }, + } + + for _, tc := range testCases { + //这里延时的原因是 保证builder 中的defer 延时操作不会导致测试的异常 + time.Sleep(time.Millisecond * 100) + redisClient.Del(context.Background(), tc.key) + fmt.Println(redisClient.Get(context.Background(), tc.key).Int64()) + t.Run(tc.name, func(t *testing.T) { + + server := gin.Default() + server.Use(tc.createMiddleware(tc.maxCount, tc.key)) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 100) + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + go func() { + tc.before(server, tc.key) + }() + time.Sleep(tc.interval) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + afterCount, err := tc.after(tc.key) + + assert.Equal(t, tc.afterCount, afterCount) + assert.Equal(t, tc.afterErr, err) + }) + } +} diff --git a/internal/mocks/redis_mock.go b/internal/mocks/redis_mock.go new file mode 100644 index 0000000..927216b --- /dev/null +++ b/internal/mocks/redis_mock.go @@ -0,0 +1,12454 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go +// +// Generated by this command: +// +// mockgen.exe -source=G:\go-up\pkg\mod\github.com\redis\go-redis\v9@v9.1.0\commands.go -package=mocks -destination=G:\go-up\src\ginx\internal\mocks\redis_mock.go +// +// Package mocks is a generated GoMock package. +package mocks + +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 +} + +// 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 +} + +// 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...) +} + +// 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) +} + +// 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) +} + +// BFReserveArgs mocks base method. +func (m *MockCmdable) BFReserveArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveArgs indicates an expected call of BFReserveArgs. +func (mr *MockCmdableMockRecorder) BFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveArgs", reflect.TypeOf((*MockCmdable)(nil).BFReserveArgs), ctx, key, options) +} + +// 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) +} + +// 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, args ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range args { + 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, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockCmdable)(nil).BitField), 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...) +} + +// 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) +} + +// 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) +} + +// CFReserveArgs mocks base method. +func (m *MockCmdable) CFReserveArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveArgs indicates an expected call of CFReserveArgs. +func (mr *MockCmdableMockRecorder) CFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveArgs", reflect.TypeOf((*MockCmdable)(nil).CFReserveArgs), ctx, key, options) +} + +// 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) +} + +// 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) +} + +// 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...) +} + +// 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) +} + +// 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) +} + +// 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...) +} + +// 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) +} + +// 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...) +} + +// 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) +} + +// 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...) +} + +// 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) +} + +// 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) +} + +// TFCall mocks base method. +func (m *MockCmdable) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockCmdableMockRecorder) TFCall(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockCmdable)(nil).TFCall), ctx, libName, funcName, numKeys) +} + +// TFCallASYNC mocks base method. +func (m *MockCmdable) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockCmdableMockRecorder) TFCallASYNC(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNC), ctx, libName, funcName, numKeys) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockCmdable) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockCmdableMockRecorder) TFCallASYNCArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNCArgs), ctx, libName, funcName, numKeys, options) +} + +// TFCallArgs mocks base method. +func (m *MockCmdable) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockCmdableMockRecorder) TFCallArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallArgs), ctx, libName, funcName, numKeys, options) +} + +// TFunctionDelete mocks base method. +func (m *MockCmdable) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockCmdableMockRecorder) TFunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockCmdable)(nil).TFunctionDelete), ctx, libName) +} + +// TFunctionList mocks base method. +func (m *MockCmdable) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockCmdableMockRecorder) TFunctionList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockCmdable)(nil).TFunctionList), ctx) +} + +// TFunctionListArgs mocks base method. +func (m *MockCmdable) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockCmdableMockRecorder) TFunctionListArgs(ctx, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionListArgs), ctx, options) +} + +// TFunctionLoad mocks base method. +func (m *MockCmdable) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockCmdableMockRecorder) TFunctionLoad(ctx, lib any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoad), ctx, lib) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockCmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockCmdableMockRecorder) TFunctionLoadArgs(ctx, lib, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoadArgs), ctx, lib, 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...) +} + +// 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...) +} + +// 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...) +} + +// 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) +} + +// 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) +} + +// 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) +} + +// MockStatefulCmdable is a mock of StatefulCmdable interface. +type MockStatefulCmdable struct { + ctrl *gomock.Controller + recorder *MockStatefulCmdableMockRecorder +} + +// MockStatefulCmdableMockRecorder is the mock recorder for MockStatefulCmdable. +type MockStatefulCmdableMockRecorder struct { + mock *MockStatefulCmdable +} + +// NewMockStatefulCmdable creates a new mock instance. +func NewMockStatefulCmdable(ctrl *gomock.Controller) *MockStatefulCmdable { + mock := &MockStatefulCmdable{ctrl: ctrl} + mock.recorder = &MockStatefulCmdableMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStatefulCmdable) EXPECT() *MockStatefulCmdableMockRecorder { + return m.recorder +} + +// ACLDryRun mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ACLDryRun), varargs...) +} + +// ACLLog mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ACLLog(ctx, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockStatefulCmdable)(nil).ACLLog), ctx, count) +} + +// ACLLogReset mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ACLLogReset(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockStatefulCmdable)(nil).ACLLogReset), ctx) +} + +// Append mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Append(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockStatefulCmdable)(nil).Append), ctx, key, value) +} + +// Auth mocks base method. +func (m *MockStatefulCmdable) Auth(ctx context.Context, password string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Auth", ctx, password) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Auth indicates an expected call of Auth. +func (mr *MockStatefulCmdableMockRecorder) Auth(ctx, password any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Auth", reflect.TypeOf((*MockStatefulCmdable)(nil).Auth), ctx, password) +} + +// AuthACL mocks base method. +func (m *MockStatefulCmdable) AuthACL(ctx context.Context, username, password string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AuthACL", ctx, username, password) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// AuthACL indicates an expected call of AuthACL. +func (mr *MockStatefulCmdableMockRecorder) AuthACL(ctx, username, password any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthACL", reflect.TypeOf((*MockStatefulCmdable)(nil).AuthACL), ctx, username, password) +} + +// BFAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFAdd(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).BFAdd), ctx, key, element) +} + +// BFCard mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockStatefulCmdable)(nil).BFCard), ctx, key) +} + +// BFExists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFExists(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockStatefulCmdable)(nil).BFExists), ctx, key, element) +} + +// BFInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfo), ctx, key) +} + +// BFInfoArg mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfoArg(ctx, key, option any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoArg), ctx, key, option) +} + +// BFInfoCapacity mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfoCapacity(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoCapacity), ctx, key) +} + +// BFInfoExpansion mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfoExpansion(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoExpansion), ctx, key) +} + +// BFInfoFilters mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfoFilters(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoFilters), ctx, key) +} + +// BFInfoItems mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfoItems(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoItems), ctx, key) +} + +// BFInfoSize mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFInfoSize(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockStatefulCmdable)(nil).BFInfoSize), ctx, key) +} + +// BFInsert mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BFInsert), varargs...) +} + +// BFLoadChunk mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFLoadChunk(ctx, key, iterator, data any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockStatefulCmdable)(nil).BFLoadChunk), ctx, key, iterator, data) +} + +// BFMAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BFMAdd), varargs...) +} + +// BFMExists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BFMExists), varargs...) +} + +// BFReserve mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFReserve(ctx, key, errorRate, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserve), ctx, key, errorRate, capacity) +} + +// BFReserveArgs mocks base method. +func (m *MockStatefulCmdable) BFReserveArgs(ctx context.Context, key string, options *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveArgs indicates an expected call of BFReserveArgs. +func (mr *MockStatefulCmdableMockRecorder) BFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserveArgs), ctx, key, options) +} + +// BFReserveExpansion mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFReserveExpansion(ctx, key, errorRate, capacity, expansion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserveExpansion), ctx, key, errorRate, capacity, expansion) +} + +// BFReserveNonScaling mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFReserveNonScaling(ctx, key, errorRate, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockStatefulCmdable)(nil).BFReserveNonScaling), ctx, key, errorRate, capacity) +} + +// BFScanDump mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BFScanDump(ctx, key, iterator any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockStatefulCmdable)(nil).BFScanDump), ctx, key, iterator) +} + +// BLMPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BLMPop), varargs...) +} + +// BLMove mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BLMove), ctx, source, destination, srcpos, destpos, timeout) +} + +// BLPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BLPop), varargs...) +} + +// BRPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BRPop), varargs...) +} + +// BRPopLPush mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BRPopLPush(ctx, source, destination, timeout any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockStatefulCmdable)(nil).BRPopLPush), ctx, source, destination, timeout) +} + +// BZMPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BZMPop), varargs...) +} + +// BZPopMax mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BZPopMax), varargs...) +} + +// BZPopMin mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BZPopMin), varargs...) +} + +// BgRewriteAOF mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BgRewriteAOF(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockStatefulCmdable)(nil).BgRewriteAOF), ctx) +} + +// BgSave mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BgSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockStatefulCmdable)(nil).BgSave), ctx) +} + +// BitCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BitCount(ctx, key, bitCount any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockStatefulCmdable)(nil).BitCount), ctx, key, bitCount) +} + +// BitField mocks base method. +func (m *MockStatefulCmdable) BitField(ctx context.Context, key string, args ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{ctx, key} + for _, a := range args { + 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 *MockStatefulCmdableMockRecorder) BitField(ctx, key any, args ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, key}, args...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockStatefulCmdable)(nil).BitField), varargs...) +} + +// BitOpAnd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BitOpAnd), varargs...) +} + +// BitOpNot mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) BitOpNot(ctx, destKey, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockStatefulCmdable)(nil).BitOpNot), ctx, destKey, key) +} + +// BitOpOr mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BitOpOr), varargs...) +} + +// BitOpXor mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BitOpXor), varargs...) +} + +// BitPos mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BitPos), varargs...) +} + +// BitPosSpan mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).BitPosSpan), ctx, key, bit, start, end, span) +} + +// CFAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFAdd(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).CFAdd), ctx, key, element) +} + +// CFAddNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFAddNX(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockStatefulCmdable)(nil).CFAddNX), ctx, key, element) +} + +// CFCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFCount(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockStatefulCmdable)(nil).CFCount), ctx, key, element) +} + +// CFDel mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFDel(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockStatefulCmdable)(nil).CFDel), ctx, key, element) +} + +// CFExists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFExists(ctx, key, element any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockStatefulCmdable)(nil).CFExists), ctx, key, element) +} + +// CFInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).CFInfo), ctx, key) +} + +// CFInsert mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CFInsert), varargs...) +} + +// CFInsertNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CFInsertNX), varargs...) +} + +// CFLoadChunk mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFLoadChunk(ctx, key, iterator, data any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockStatefulCmdable)(nil).CFLoadChunk), ctx, key, iterator, data) +} + +// CFMExists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CFMExists), varargs...) +} + +// CFReserve mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFReserve(ctx, key, capacity any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserve), ctx, key, capacity) +} + +// CFReserveArgs mocks base method. +func (m *MockStatefulCmdable) CFReserveArgs(ctx context.Context, key string, options *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveArgs", ctx, key, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveArgs indicates an expected call of CFReserveArgs. +func (mr *MockStatefulCmdableMockRecorder) CFReserveArgs(ctx, key, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveArgs), ctx, key, options) +} + +// CFReserveBucketSize mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFReserveBucketSize(ctx, key, capacity, bucketsize any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveBucketSize), ctx, key, capacity, bucketsize) +} + +// CFReserveExpansion mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFReserveExpansion(ctx, key, capacity, expansion any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveExpansion), ctx, key, capacity, expansion) +} + +// CFReserveMaxIterations mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFReserveMaxIterations(ctx, key, capacity, maxiterations any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockStatefulCmdable)(nil).CFReserveMaxIterations), ctx, key, capacity, maxiterations) +} + +// CFScanDump mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CFScanDump(ctx, key, iterator any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockStatefulCmdable)(nil).CFScanDump), ctx, key, iterator) +} + +// CMSIncrBy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CMSIncrBy), varargs...) +} + +// CMSInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CMSInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSInfo), ctx, key) +} + +// CMSInitByDim mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CMSInitByDim(ctx, key, width, height any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSInitByDim), ctx, key, width, height) +} + +// CMSInitByProb mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CMSInitByProb(ctx, key, errorRate, probability any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSInitByProb), ctx, key, errorRate, probability) +} + +// CMSMerge mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CMSMerge), varargs...) +} + +// CMSMergeWithWeight mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CMSMergeWithWeight(ctx, destKey, sourceKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockStatefulCmdable)(nil).CMSMergeWithWeight), ctx, destKey, sourceKeys) +} + +// CMSQuery mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CMSQuery), varargs...) +} + +// ClientGetName mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientGetName(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientGetName), ctx) +} + +// ClientID mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientID), ctx) +} + +// ClientInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientInfo(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientInfo), ctx) +} + +// ClientKill mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientKill(ctx, ipPort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientKill), ctx, ipPort) +} + +// ClientKillByFilter mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ClientKillByFilter), varargs...) +} + +// ClientList mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientList), ctx) +} + +// ClientPause mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientPause(ctx, dur any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientPause), ctx, dur) +} + +// ClientSetName mocks base method. +func (m *MockStatefulCmdable) ClientSetName(ctx context.Context, name string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientSetName", ctx, name) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientSetName indicates an expected call of ClientSetName. +func (mr *MockStatefulCmdableMockRecorder) ClientSetName(ctx, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientSetName", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientSetName), ctx, name) +} + +// ClientUnblock mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientUnblock(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientUnblock), ctx, id) +} + +// ClientUnblockWithError mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientUnblockWithError(ctx, id any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientUnblockWithError), ctx, id) +} + +// ClientUnpause mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClientUnpause(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockStatefulCmdable)(nil).ClientUnpause), ctx) +} + +// ClusterAddSlots mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ClusterAddSlots), varargs...) +} + +// ClusterAddSlotsRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterAddSlotsRange(ctx, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterAddSlotsRange), ctx, min, max) +} + +// ClusterCountFailureReports mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterCountFailureReports(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterCountFailureReports), ctx, nodeID) +} + +// ClusterCountKeysInSlot mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterCountKeysInSlot(ctx, slot any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterCountKeysInSlot), ctx, slot) +} + +// ClusterDelSlots mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ClusterDelSlots), varargs...) +} + +// ClusterDelSlotsRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterDelSlotsRange(ctx, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterDelSlotsRange), ctx, min, max) +} + +// ClusterFailover mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterFailover(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterFailover), ctx) +} + +// ClusterForget mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterForget(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterForget), ctx, nodeID) +} + +// ClusterGetKeysInSlot mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterGetKeysInSlot(ctx, slot, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterGetKeysInSlot), ctx, slot, count) +} + +// ClusterInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterInfo(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterInfo), ctx) +} + +// ClusterKeySlot mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterKeySlot(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterKeySlot), ctx, key) +} + +// ClusterLinks mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterLinks(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterLinks), ctx) +} + +// ClusterMeet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterMeet(ctx, host, port any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterMeet), ctx, host, port) +} + +// ClusterMyShardID mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterMyShardID(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterMyShardID), ctx) +} + +// ClusterNodes mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterNodes(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterNodes), ctx) +} + +// ClusterReplicate mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterReplicate(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterReplicate), ctx, nodeID) +} + +// ClusterResetHard mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterResetHard(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterResetHard), ctx) +} + +// ClusterResetSoft mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterResetSoft(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterResetSoft), ctx) +} + +// ClusterSaveConfig mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterSaveConfig(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterSaveConfig), ctx) +} + +// ClusterShards mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterShards(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterShards), ctx) +} + +// ClusterSlaves mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterSlaves(ctx, nodeID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterSlaves), ctx, nodeID) +} + +// ClusterSlots mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ClusterSlots(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockStatefulCmdable)(nil).ClusterSlots), ctx) +} + +// Command mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Command(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockStatefulCmdable)(nil).Command), ctx) +} + +// CommandGetKeys mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CommandGetKeys), varargs...) +} + +// CommandGetKeysAndFlags mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).CommandGetKeysAndFlags), varargs...) +} + +// CommandList mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) CommandList(ctx, filter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockStatefulCmdable)(nil).CommandList), ctx, filter) +} + +// ConfigGet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ConfigGet(ctx, parameter any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigGet), ctx, parameter) +} + +// ConfigResetStat mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ConfigResetStat(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigResetStat), ctx) +} + +// ConfigRewrite mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ConfigRewrite(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigRewrite), ctx) +} + +// ConfigSet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ConfigSet(ctx, parameter, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockStatefulCmdable)(nil).ConfigSet), ctx, parameter, value) +} + +// Copy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Copy(ctx, sourceKey, destKey, db, replace any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockStatefulCmdable)(nil).Copy), ctx, sourceKey, destKey, db, replace) +} + +// DBSize mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) DBSize(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockStatefulCmdable)(nil).DBSize), ctx) +} + +// DebugObject mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) DebugObject(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockStatefulCmdable)(nil).DebugObject), ctx, key) +} + +// Decr mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Decr(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockStatefulCmdable)(nil).Decr), ctx, key) +} + +// DecrBy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) DecrBy(ctx, key, decrement any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).DecrBy), ctx, key, decrement) +} + +// Del mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Del), varargs...) +} + +// Dump mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Dump(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockStatefulCmdable)(nil).Dump), ctx, key) +} + +// Echo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Echo(ctx, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockStatefulCmdable)(nil).Echo), ctx, message) +} + +// Eval mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Eval), varargs...) +} + +// EvalRO mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).EvalRO), varargs...) +} + +// EvalSha mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).EvalSha), varargs...) +} + +// EvalShaRO mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).EvalShaRO), varargs...) +} + +// Exists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Exists), varargs...) +} + +// Expire mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Expire(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockStatefulCmdable)(nil).Expire), ctx, key, expiration) +} + +// ExpireAt mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ExpireAt(ctx, key, tm any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireAt), ctx, key, tm) +} + +// ExpireGT mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ExpireGT(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireGT), ctx, key, expiration) +} + +// ExpireLT mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ExpireLT(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireLT), ctx, key, expiration) +} + +// ExpireNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ExpireNX(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireNX), ctx, key, expiration) +} + +// ExpireTime mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ExpireTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireTime), ctx, key) +} + +// ExpireXX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ExpireXX(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockStatefulCmdable)(nil).ExpireXX), ctx, key, expiration) +} + +// FCall mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).FCall), varargs...) +} + +// FCallRO mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).FCallRO), varargs...) +} + +// FCallRo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).FCallRo), varargs...) +} + +// FlushAll mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FlushAll(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushAll), ctx) +} + +// FlushAllAsync mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FlushAllAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushAllAsync), ctx) +} + +// FlushDB mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FlushDB(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushDB), ctx) +} + +// FlushDBAsync mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FlushDBAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockStatefulCmdable)(nil).FlushDBAsync), ctx) +} + +// FunctionDelete mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionDelete), ctx, libName) +} + +// FunctionDump mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionDump(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionDump), ctx) +} + +// FunctionFlush mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionFlush(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionFlush), ctx) +} + +// FunctionFlushAsync mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionFlushAsync(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionFlushAsync), ctx) +} + +// FunctionKill mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionKill(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionKill), ctx) +} + +// FunctionList mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionList(ctx, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionList), ctx, q) +} + +// FunctionLoad mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionLoad(ctx, code any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionLoad), ctx, code) +} + +// FunctionLoadReplace mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionLoadReplace(ctx, code any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionLoadReplace), ctx, code) +} + +// FunctionRestore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionRestore(ctx, libDump any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionRestore), ctx, libDump) +} + +// FunctionStats mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) FunctionStats(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockStatefulCmdable)(nil).FunctionStats), ctx) +} + +// GeoAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).GeoAdd), varargs...) +} + +// GeoDist mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoDist(ctx, key, member1, member2, unit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoDist), ctx, key, member1, member2, unit) +} + +// GeoHash mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).GeoHash), varargs...) +} + +// GeoPos mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).GeoPos), varargs...) +} + +// GeoRadius mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoRadius(ctx, key, longitude, latitude, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadius), ctx, key, longitude, latitude, query) +} + +// GeoRadiusByMember mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoRadiusByMember(ctx, key, member, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadiusByMember), ctx, key, member, query) +} + +// GeoRadiusByMemberStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoRadiusByMemberStore(ctx, key, member, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadiusByMemberStore), ctx, key, member, query) +} + +// GeoRadiusStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoRadiusStore(ctx, key, longitude, latitude, query any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoRadiusStore), ctx, key, longitude, latitude, query) +} + +// GeoSearch mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoSearch(ctx, key, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoSearch), ctx, key, q) +} + +// GeoSearchLocation mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoSearchLocation(ctx, key, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoSearchLocation), ctx, key, q) +} + +// GeoSearchStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GeoSearchStore(ctx, key, store, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockStatefulCmdable)(nil).GeoSearchStore), ctx, key, store, q) +} + +// Get mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Get(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockStatefulCmdable)(nil).Get), ctx, key) +} + +// GetBit mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GetBit(ctx, key, offset any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockStatefulCmdable)(nil).GetBit), ctx, key, offset) +} + +// GetDel mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GetDel(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockStatefulCmdable)(nil).GetDel), ctx, key) +} + +// GetEx mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GetEx(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockStatefulCmdable)(nil).GetEx), ctx, key, expiration) +} + +// GetRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GetRange(ctx, key, start, end any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockStatefulCmdable)(nil).GetRange), ctx, key, start, end) +} + +// GetSet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) GetSet(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockStatefulCmdable)(nil).GetSet), ctx, key, value) +} + +// HDel mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).HDel), varargs...) +} + +// HExists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HExists(ctx, key, field any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockStatefulCmdable)(nil).HExists), ctx, key, field) +} + +// HGet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HGet(ctx, key, field any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockStatefulCmdable)(nil).HGet), ctx, key, field) +} + +// HGetAll mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HGetAll(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockStatefulCmdable)(nil).HGetAll), ctx, key) +} + +// HIncrBy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HIncrBy(ctx, key, field, incr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).HIncrBy), ctx, key, field, incr) +} + +// HIncrByFloat mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HIncrByFloat(ctx, key, field, incr any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockStatefulCmdable)(nil).HIncrByFloat), ctx, key, field, incr) +} + +// HKeys mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HKeys(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockStatefulCmdable)(nil).HKeys), ctx, key) +} + +// HLen mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockStatefulCmdable)(nil).HLen), ctx, key) +} + +// HMGet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).HMGet), varargs...) +} + +// HMSet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).HMSet), varargs...) +} + +// HRandField mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HRandField(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockStatefulCmdable)(nil).HRandField), ctx, key, count) +} + +// HRandFieldWithValues mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HRandFieldWithValues(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockStatefulCmdable)(nil).HRandFieldWithValues), ctx, key, count) +} + +// HScan mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockStatefulCmdable)(nil).HScan), ctx, key, cursor, match, count) +} + +// HSet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).HSet), varargs...) +} + +// HSetNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HSetNX(ctx, key, field, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockStatefulCmdable)(nil).HSetNX), ctx, key, field, value) +} + +// HVals mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) HVals(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockStatefulCmdable)(nil).HVals), ctx, key) +} + +// Hello mocks base method. +func (m *MockStatefulCmdable) Hello(ctx context.Context, ver int, username, password, clientName string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Hello", ctx, ver, username, password, clientName) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// Hello indicates an expected call of Hello. +func (mr *MockStatefulCmdableMockRecorder) Hello(ctx, ver, username, password, clientName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Hello", reflect.TypeOf((*MockStatefulCmdable)(nil).Hello), ctx, ver, username, password, clientName) +} + +// Incr mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Incr(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockStatefulCmdable)(nil).Incr), ctx, key) +} + +// IncrBy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) IncrBy(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).IncrBy), ctx, key, value) +} + +// IncrByFloat mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) IncrByFloat(ctx, key, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockStatefulCmdable)(nil).IncrByFloat), ctx, key, value) +} + +// Info mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Info), varargs...) +} + +// Keys mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Keys(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockStatefulCmdable)(nil).Keys), ctx, pattern) +} + +// LCS mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LCS(ctx, q any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockStatefulCmdable)(nil).LCS), ctx, q) +} + +// LIndex mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LIndex(ctx, key, index any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockStatefulCmdable)(nil).LIndex), ctx, key, index) +} + +// LInsert mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LInsert(ctx, key, op, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockStatefulCmdable)(nil).LInsert), ctx, key, op, pivot, value) +} + +// LInsertAfter mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LInsertAfter(ctx, key, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockStatefulCmdable)(nil).LInsertAfter), ctx, key, pivot, value) +} + +// LInsertBefore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LInsertBefore(ctx, key, pivot, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockStatefulCmdable)(nil).LInsertBefore), ctx, key, pivot, value) +} + +// LLen mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockStatefulCmdable)(nil).LLen), ctx, key) +} + +// LMPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).LMPop), varargs...) +} + +// LMove mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LMove(ctx, source, destination, srcpos, destpos any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockStatefulCmdable)(nil).LMove), ctx, source, destination, srcpos, destpos) +} + +// LPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockStatefulCmdable)(nil).LPop), ctx, key) +} + +// LPopCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LPopCount(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockStatefulCmdable)(nil).LPopCount), ctx, key, count) +} + +// LPos mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LPos(ctx, key, value, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockStatefulCmdable)(nil).LPos), ctx, key, value, args) +} + +// LPosCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LPosCount(ctx, key, value, count, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockStatefulCmdable)(nil).LPosCount), ctx, key, value, count, args) +} + +// LPush mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).LPush), varargs...) +} + +// LPushX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).LPushX), varargs...) +} + +// LRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockStatefulCmdable)(nil).LRange), ctx, key, start, stop) +} + +// LRem mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LRem(ctx, key, count, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockStatefulCmdable)(nil).LRem), ctx, key, count, value) +} + +// LSet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LSet(ctx, key, index, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockStatefulCmdable)(nil).LSet), ctx, key, index, value) +} + +// LTrim mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LTrim(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockStatefulCmdable)(nil).LTrim), ctx, key, start, stop) +} + +// LastSave mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) LastSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockStatefulCmdable)(nil).LastSave), ctx) +} + +// MGet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).MGet), varargs...) +} + +// MSet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).MSet), varargs...) +} + +// MSetNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).MSetNX), varargs...) +} + +// MemoryUsage mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).MemoryUsage), varargs...) +} + +// Migrate mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Migrate), ctx, host, port, key, db, timeout) +} + +// ModuleLoadex mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ModuleLoadex(ctx, conf any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockStatefulCmdable)(nil).ModuleLoadex), ctx, conf) +} + +// Move mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Move(ctx, key, db any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockStatefulCmdable)(nil).Move), ctx, key, db) +} + +// ObjectEncoding mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ObjectEncoding(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockStatefulCmdable)(nil).ObjectEncoding), ctx, key) +} + +// ObjectIdleTime mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ObjectIdleTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockStatefulCmdable)(nil).ObjectIdleTime), ctx, key) +} + +// ObjectRefCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ObjectRefCount(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockStatefulCmdable)(nil).ObjectRefCount), ctx, key) +} + +// PExpire mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PExpire(ctx, key, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockStatefulCmdable)(nil).PExpire), ctx, key, expiration) +} + +// PExpireAt mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PExpireAt(ctx, key, tm any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockStatefulCmdable)(nil).PExpireAt), ctx, key, tm) +} + +// PExpireTime mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PExpireTime(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockStatefulCmdable)(nil).PExpireTime), ctx, key) +} + +// PFAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).PFAdd), varargs...) +} + +// PFCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).PFCount), varargs...) +} + +// PFMerge mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).PFMerge), varargs...) +} + +// PTTL mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PTTL(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockStatefulCmdable)(nil).PTTL), ctx, key) +} + +// Persist mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Persist(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockStatefulCmdable)(nil).Persist), ctx, key) +} + +// Ping mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Ping(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockStatefulCmdable)(nil).Ping), ctx) +} + +// Pipeline mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Pipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockStatefulCmdable)(nil).Pipeline)) +} + +// Pipelined mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Pipelined(ctx, fn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockStatefulCmdable)(nil).Pipelined), ctx, fn) +} + +// PubSubChannels mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PubSubChannels(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubChannels), ctx, pattern) +} + +// PubSubNumPat mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PubSubNumPat(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubNumPat), ctx) +} + +// PubSubNumSub mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).PubSubNumSub), varargs...) +} + +// PubSubShardChannels mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) PubSubShardChannels(ctx, pattern any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockStatefulCmdable)(nil).PubSubShardChannels), ctx, pattern) +} + +// PubSubShardNumSub mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).PubSubShardNumSub), varargs...) +} + +// Publish mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Publish(ctx, channel, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockStatefulCmdable)(nil).Publish), ctx, channel, message) +} + +// Quit mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Quit(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockStatefulCmdable)(nil).Quit), ctx) +} + +// RPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) RPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockStatefulCmdable)(nil).RPop), ctx, key) +} + +// RPopCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) RPopCount(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockStatefulCmdable)(nil).RPopCount), ctx, key, count) +} + +// RPopLPush mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) RPopLPush(ctx, source, destination any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockStatefulCmdable)(nil).RPopLPush), ctx, source, destination) +} + +// RPush mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).RPush), varargs...) +} + +// RPushX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).RPushX), varargs...) +} + +// RandomKey mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) RandomKey(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockStatefulCmdable)(nil).RandomKey), ctx) +} + +// ReadOnly mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ReadOnly(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockStatefulCmdable)(nil).ReadOnly), ctx) +} + +// ReadWrite mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ReadWrite(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockStatefulCmdable)(nil).ReadWrite), ctx) +} + +// Rename mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Rename(ctx, key, newkey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockStatefulCmdable)(nil).Rename), ctx, key, newkey) +} + +// RenameNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) RenameNX(ctx, key, newkey any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockStatefulCmdable)(nil).RenameNX), ctx, key, newkey) +} + +// Restore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Restore(ctx, key, ttl, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockStatefulCmdable)(nil).Restore), ctx, key, ttl, value) +} + +// RestoreReplace mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) RestoreReplace(ctx, key, ttl, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockStatefulCmdable)(nil).RestoreReplace), ctx, key, ttl, value) +} + +// SAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SAdd), varargs...) +} + +// SCard mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockStatefulCmdable)(nil).SCard), ctx, key) +} + +// SDiff mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SDiff), varargs...) +} + +// SDiffStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SDiffStore), varargs...) +} + +// SInter mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SInter), varargs...) +} + +// SInterCard mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SInterCard), varargs...) +} + +// SInterStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SInterStore), varargs...) +} + +// SIsMember mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SIsMember(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockStatefulCmdable)(nil).SIsMember), ctx, key, member) +} + +// SMIsMember mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SMIsMember), varargs...) +} + +// SMembers mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SMembers(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockStatefulCmdable)(nil).SMembers), ctx, key) +} + +// SMembersMap mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SMembersMap(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockStatefulCmdable)(nil).SMembersMap), ctx, key) +} + +// SMove mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SMove(ctx, source, destination, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockStatefulCmdable)(nil).SMove), ctx, source, destination, member) +} + +// SPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SPop(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockStatefulCmdable)(nil).SPop), ctx, key) +} + +// SPopN mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SPopN(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockStatefulCmdable)(nil).SPopN), ctx, key, count) +} + +// SPublish mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SPublish(ctx, channel, message any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockStatefulCmdable)(nil).SPublish), ctx, channel, message) +} + +// SRandMember mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SRandMember(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockStatefulCmdable)(nil).SRandMember), ctx, key) +} + +// SRandMemberN mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SRandMemberN(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockStatefulCmdable)(nil).SRandMemberN), ctx, key, count) +} + +// SRem mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SRem), varargs...) +} + +// SScan mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockStatefulCmdable)(nil).SScan), ctx, key, cursor, match, count) +} + +// SUnion mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SUnion), varargs...) +} + +// SUnionStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).SUnionStore), varargs...) +} + +// Save mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Save(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockStatefulCmdable)(nil).Save), ctx) +} + +// Scan mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Scan(ctx, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockStatefulCmdable)(nil).Scan), ctx, cursor, match, count) +} + +// ScanType mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ScanType(ctx, cursor, match, count, keyType any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockStatefulCmdable)(nil).ScanType), ctx, cursor, match, count, keyType) +} + +// ScriptExists mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ScriptExists), varargs...) +} + +// ScriptFlush mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ScriptFlush(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptFlush), ctx) +} + +// ScriptKill mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ScriptKill(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptKill), ctx) +} + +// ScriptLoad mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ScriptLoad(ctx, script any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockStatefulCmdable)(nil).ScriptLoad), ctx, script) +} + +// Select mocks base method. +func (m *MockStatefulCmdable) Select(ctx context.Context, index int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Select", ctx, index) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Select indicates an expected call of Select. +func (mr *MockStatefulCmdableMockRecorder) Select(ctx, index any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Select", reflect.TypeOf((*MockStatefulCmdable)(nil).Select), ctx, index) +} + +// Set mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Set(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockStatefulCmdable)(nil).Set), ctx, key, value, expiration) +} + +// SetArgs mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SetArgs(ctx, key, value, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).SetArgs), ctx, key, value, a) +} + +// SetBit mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SetBit(ctx, key, offset, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockStatefulCmdable)(nil).SetBit), ctx, key, offset, value) +} + +// SetEx mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SetEx(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockStatefulCmdable)(nil).SetEx), ctx, key, value, expiration) +} + +// SetNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SetNX(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockStatefulCmdable)(nil).SetNX), ctx, key, value, expiration) +} + +// SetRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SetRange(ctx, key, offset, value any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockStatefulCmdable)(nil).SetRange), ctx, key, offset, value) +} + +// SetXX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SetXX(ctx, key, value, expiration any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockStatefulCmdable)(nil).SetXX), ctx, key, value, expiration) +} + +// Shutdown mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Shutdown(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockStatefulCmdable)(nil).Shutdown), ctx) +} + +// ShutdownNoSave mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ShutdownNoSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockStatefulCmdable)(nil).ShutdownNoSave), ctx) +} + +// ShutdownSave mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ShutdownSave(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockStatefulCmdable)(nil).ShutdownSave), ctx) +} + +// SlaveOf mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SlaveOf(ctx, host, port any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockStatefulCmdable)(nil).SlaveOf), ctx, host, port) +} + +// SlowLogGet mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SlowLogGet(ctx, num any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockStatefulCmdable)(nil).SlowLogGet), ctx, num) +} + +// Sort mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Sort(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockStatefulCmdable)(nil).Sort), ctx, key, sort) +} + +// SortInterfaces mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SortInterfaces(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockStatefulCmdable)(nil).SortInterfaces), ctx, key, sort) +} + +// SortRO mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SortRO(ctx, key, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockStatefulCmdable)(nil).SortRO), ctx, key, sort) +} + +// SortStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) SortStore(ctx, key, store, sort any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockStatefulCmdable)(nil).SortStore), ctx, key, store, sort) +} + +// StrLen mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) StrLen(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockStatefulCmdable)(nil).StrLen), ctx, key) +} + +// SwapDB mocks base method. +func (m *MockStatefulCmdable) SwapDB(ctx context.Context, index1, index2 int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SwapDB", ctx, index1, index2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SwapDB indicates an expected call of SwapDB. +func (mr *MockStatefulCmdableMockRecorder) SwapDB(ctx, index1, index2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SwapDB", reflect.TypeOf((*MockStatefulCmdable)(nil).SwapDB), ctx, index1, index2) +} + +// TDigestAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestAdd), varargs...) +} + +// TDigestByRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestByRank), varargs...) +} + +// TDigestByRevRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestByRevRank), varargs...) +} + +// TDigestCDF mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestCDF), varargs...) +} + +// TDigestCreate mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestCreate(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestCreate), ctx, key) +} + +// TDigestCreateWithCompression mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestCreateWithCompression(ctx, key, compression any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestCreateWithCompression), ctx, key, compression) +} + +// TDigestInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestInfo), ctx, key) +} + +// TDigestMax mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestMax(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestMax), ctx, key) +} + +// TDigestMerge mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestMerge), varargs...) +} + +// TDigestMin mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestMin(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestMin), ctx, key) +} + +// TDigestQuantile mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestQuantile), varargs...) +} + +// TDigestRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestRank), varargs...) +} + +// TDigestReset mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestReset(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestReset), ctx, key) +} + +// TDigestRevRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TDigestRevRank), varargs...) +} + +// TDigestTrimmedMean mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TDigestTrimmedMean(ctx, key, lowCutQuantile, highCutQuantile any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockStatefulCmdable)(nil).TDigestTrimmedMean), ctx, key, lowCutQuantile, highCutQuantile) +} + +// TFCall mocks base method. +func (m *MockStatefulCmdable) TFCall(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockStatefulCmdableMockRecorder) TFCall(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCall), ctx, libName, funcName, numKeys) +} + +// TFCallASYNC mocks base method. +func (m *MockStatefulCmdable) TFCallASYNC(ctx context.Context, libName, funcName string, numKeys int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", ctx, libName, funcName, numKeys) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockStatefulCmdableMockRecorder) TFCallASYNC(ctx, libName, funcName, numKeys any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCallASYNC), ctx, libName, funcName, numKeys) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockStatefulCmdable) TFCallASYNCArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockStatefulCmdableMockRecorder) TFCallASYNCArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCallASYNCArgs), ctx, libName, funcName, numKeys, options) +} + +// TFCallArgs mocks base method. +func (m *MockStatefulCmdable) TFCallArgs(ctx context.Context, libName, funcName string, numKeys int, options *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", ctx, libName, funcName, numKeys, options) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockStatefulCmdableMockRecorder) TFCallArgs(ctx, libName, funcName, numKeys, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFCallArgs), ctx, libName, funcName, numKeys, options) +} + +// TFunctionDelete mocks base method. +func (m *MockStatefulCmdable) TFunctionDelete(ctx context.Context, libName string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", ctx, libName) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockStatefulCmdableMockRecorder) TFunctionDelete(ctx, libName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionDelete), ctx, libName) +} + +// TFunctionList mocks base method. +func (m *MockStatefulCmdable) TFunctionList(ctx context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", ctx) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockStatefulCmdableMockRecorder) TFunctionList(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionList), ctx) +} + +// TFunctionListArgs mocks base method. +func (m *MockStatefulCmdable) TFunctionListArgs(ctx context.Context, options *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", ctx, options) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockStatefulCmdableMockRecorder) TFunctionListArgs(ctx, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionListArgs), ctx, options) +} + +// TFunctionLoad mocks base method. +func (m *MockStatefulCmdable) TFunctionLoad(ctx context.Context, lib string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", ctx, lib) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockStatefulCmdableMockRecorder) TFunctionLoad(ctx, lib any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionLoad), ctx, lib) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockStatefulCmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", ctx, lib, options) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockStatefulCmdableMockRecorder) TFunctionLoadArgs(ctx, lib, options any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).TFunctionLoadArgs), ctx, lib, options) +} + +// TTL mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TTL(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockStatefulCmdable)(nil).TTL), ctx, key) +} + +// Time mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Time(ctx any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockStatefulCmdable)(nil).Time), ctx) +} + +// TopKAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TopKAdd), varargs...) +} + +// TopKCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TopKCount), varargs...) +} + +// TopKIncrBy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TopKIncrBy), varargs...) +} + +// TopKInfo mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TopKInfo(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKInfo), ctx, key) +} + +// TopKList mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TopKList(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKList), ctx, key) +} + +// TopKListWithCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TopKListWithCount(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKListWithCount), ctx, key) +} + +// TopKQuery mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TopKQuery), varargs...) +} + +// TopKReserve mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TopKReserve(ctx, key, k any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockStatefulCmdable)(nil).TopKReserve), ctx, key, k) +} + +// TopKReserveWithOptions mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).TopKReserveWithOptions), ctx, key, k, width, depth, decay) +} + +// Touch mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Touch), varargs...) +} + +// TxPipeline mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TxPipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockStatefulCmdable)(nil).TxPipeline)) +} + +// TxPipelined mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) TxPipelined(ctx, fn any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockStatefulCmdable)(nil).TxPipelined), ctx, fn) +} + +// Type mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) Type(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockStatefulCmdable)(nil).Type), ctx, key) +} + +// Unlink mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).Unlink), varargs...) +} + +// XAck mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).XAck), varargs...) +} + +// XAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XAdd(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockStatefulCmdable)(nil).XAdd), ctx, a) +} + +// XAutoClaim mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XAutoClaim(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockStatefulCmdable)(nil).XAutoClaim), ctx, a) +} + +// XAutoClaimJustID mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XAutoClaimJustID(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockStatefulCmdable)(nil).XAutoClaimJustID), ctx, a) +} + +// XClaim mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XClaim(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockStatefulCmdable)(nil).XClaim), ctx, a) +} + +// XClaimJustID mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XClaimJustID(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockStatefulCmdable)(nil).XClaimJustID), ctx, a) +} + +// XDel mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).XDel), varargs...) +} + +// XGroupCreate mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XGroupCreate(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupCreate), ctx, stream, group, start) +} + +// XGroupCreateConsumer mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XGroupCreateConsumer(ctx, stream, group, consumer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupCreateConsumer), ctx, stream, group, consumer) +} + +// XGroupCreateMkStream mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XGroupCreateMkStream(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupCreateMkStream), ctx, stream, group, start) +} + +// XGroupDelConsumer mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XGroupDelConsumer(ctx, stream, group, consumer any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupDelConsumer), ctx, stream, group, consumer) +} + +// XGroupDestroy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XGroupDestroy(ctx, stream, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupDestroy), ctx, stream, group) +} + +// XGroupSetID mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XGroupSetID(ctx, stream, group, start any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockStatefulCmdable)(nil).XGroupSetID), ctx, stream, group, start) +} + +// XInfoConsumers mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XInfoConsumers(ctx, key, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoConsumers), ctx, key, group) +} + +// XInfoGroups mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XInfoGroups(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoGroups), ctx, key) +} + +// XInfoStream mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XInfoStream(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoStream), ctx, key) +} + +// XInfoStreamFull mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XInfoStreamFull(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockStatefulCmdable)(nil).XInfoStreamFull), ctx, key, count) +} + +// XLen mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XLen(ctx, stream any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockStatefulCmdable)(nil).XLen), ctx, stream) +} + +// XPending mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XPending(ctx, stream, group any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockStatefulCmdable)(nil).XPending), ctx, stream, group) +} + +// XPendingExt mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XPendingExt(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockStatefulCmdable)(nil).XPendingExt), ctx, a) +} + +// XRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XRange(ctx, stream, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockStatefulCmdable)(nil).XRange), ctx, stream, start, stop) +} + +// XRangeN mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XRangeN(ctx, stream, start, stop, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockStatefulCmdable)(nil).XRangeN), ctx, stream, start, stop, count) +} + +// XRead mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XRead(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockStatefulCmdable)(nil).XRead), ctx, a) +} + +// XReadGroup mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XReadGroup(ctx, a any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockStatefulCmdable)(nil).XReadGroup), ctx, a) +} + +// XReadStreams mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).XReadStreams), varargs...) +} + +// XRevRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XRevRange(ctx, stream, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockStatefulCmdable)(nil).XRevRange), ctx, stream, start, stop) +} + +// XRevRangeN mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XRevRangeN(ctx, stream, start, stop, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockStatefulCmdable)(nil).XRevRangeN), ctx, stream, start, stop, count) +} + +// XTrimMaxLen mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XTrimMaxLen(ctx, key, maxLen any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMaxLen), ctx, key, maxLen) +} + +// XTrimMaxLenApprox mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XTrimMaxLenApprox(ctx, key, maxLen, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMaxLenApprox), ctx, key, maxLen, limit) +} + +// XTrimMinID mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XTrimMinID(ctx, key, minID any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMinID), ctx, key, minID) +} + +// XTrimMinIDApprox mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) XTrimMinIDApprox(ctx, key, minID, limit any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockStatefulCmdable)(nil).XTrimMinIDApprox), ctx, key, minID, limit) +} + +// ZAdd mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZAdd), varargs...) +} + +// ZAddArgs mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZAddArgs(ctx, key, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddArgs), ctx, key, args) +} + +// ZAddArgsIncr mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZAddArgsIncr(ctx, key, args any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockStatefulCmdable)(nil).ZAddArgsIncr), ctx, key, args) +} + +// ZAddGT mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZAddGT), varargs...) +} + +// ZAddLT mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZAddLT), varargs...) +} + +// ZAddNX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZAddNX), varargs...) +} + +// ZAddXX mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZAddXX), varargs...) +} + +// ZCard mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZCard(ctx, key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockStatefulCmdable)(nil).ZCard), ctx, key) +} + +// ZCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZCount(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockStatefulCmdable)(nil).ZCount), ctx, key, min, max) +} + +// ZDiff mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZDiff), varargs...) +} + +// ZDiffStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZDiffStore), varargs...) +} + +// ZDiffWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZDiffWithScores), varargs...) +} + +// ZIncrBy mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZIncrBy(ctx, key, increment, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockStatefulCmdable)(nil).ZIncrBy), ctx, key, increment, member) +} + +// ZInter mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZInter(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInter), ctx, store) +} + +// ZInterCard mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZInterCard), varargs...) +} + +// ZInterStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZInterStore(ctx, destination, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterStore), ctx, destination, store) +} + +// ZInterWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZInterWithScores(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZInterWithScores), ctx, store) +} + +// ZLexCount mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZLexCount(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockStatefulCmdable)(nil).ZLexCount), ctx, key, min, max) +} + +// ZMPop mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZMPop), varargs...) +} + +// ZMScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZMScore), varargs...) +} + +// ZPopMax mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZPopMax), varargs...) +} + +// ZPopMin mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZPopMin), varargs...) +} + +// ZRandMember mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRandMember(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRandMember), ctx, key, count) +} + +// ZRandMemberWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRandMemberWithScores(ctx, key, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRandMemberWithScores), ctx, key, count) +} + +// ZRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRange), ctx, key, start, stop) +} + +// ZRangeArgs mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeArgs(ctx, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeArgs), ctx, z) +} + +// ZRangeArgsWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeArgsWithScores(ctx, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeArgsWithScores), ctx, z) +} + +// ZRangeByLex mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeByLex(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByLex), ctx, key, opt) +} + +// ZRangeByScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeByScore(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByScore), ctx, key, opt) +} + +// ZRangeByScoreWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeByScoreWithScores), ctx, key, opt) +} + +// ZRangeStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeStore(ctx, dst, z any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeStore), ctx, dst, z) +} + +// ZRangeWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRangeWithScores(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRangeWithScores), ctx, key, start, stop) +} + +// ZRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRank(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRank), ctx, key, member) +} + +// ZRankWithScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRankWithScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRankWithScore), ctx, key, member) +} + +// ZRem mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) 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((*MockStatefulCmdable)(nil).ZRem), varargs...) +} + +// ZRemRangeByLex mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRemRangeByLex(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRemRangeByLex), ctx, key, min, max) +} + +// ZRemRangeByRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRemRangeByRank(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRemRangeByRank), ctx, key, start, stop) +} + +// ZRemRangeByScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRemRangeByScore(ctx, key, min, max any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRemRangeByScore), ctx, key, min, max) +} + +// ZRevRange mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRange(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRange), ctx, key, start, stop) +} + +// ZRevRangeByLex mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRangeByLex(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByLex), ctx, key, opt) +} + +// ZRevRangeByScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRangeByScore(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByScore), ctx, key, opt) +} + +// ZRevRangeByScoreWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRangeByScoreWithScores(ctx, key, opt any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeByScoreWithScores), ctx, key, opt) +} + +// ZRevRangeWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRangeWithScores(ctx, key, start, stop any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRangeWithScores), ctx, key, start, stop) +} + +// ZRevRank mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRank(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRank), ctx, key, member) +} + +// ZRevRankWithScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZRevRankWithScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZRevRankWithScore), ctx, key, member) +} + +// ZScan mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZScan(ctx, key, cursor, match, count any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockStatefulCmdable)(nil).ZScan), ctx, key, cursor, match, count) +} + +// ZScore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZScore(ctx, key, member any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZScore), ctx, key, member) +} + +// ZUnion mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZUnion(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnion), ctx, store) +} + +// ZUnionStore mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZUnionStore(ctx, dest, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnionStore), ctx, dest, store) +} + +// ZUnionWithScores mocks base method. +func (m *MockStatefulCmdable) 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 *MockStatefulCmdableMockRecorder) ZUnionWithScores(ctx, store any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockStatefulCmdable)(nil).ZUnionWithScores), ctx, store) +} diff --git a/middlewares/activelimit/locallimit/builder.go b/middlewares/activelimit/locallimit/builder.go new file mode 100644 index 0000000..9784d2d --- /dev/null +++ b/middlewares/activelimit/locallimit/builder.go @@ -0,0 +1,43 @@ +package locallimit + +import ( + "github.com/gin-gonic/gin" + "go.uber.org/atomic" + "net/http" +) + +type LocalActiveLimit struct { + //最大限制个数 + maxActive *atomic.Int64 + //当前活跃个数 + countActive *atomic.Int64 +} + +// NewLocalActiveLimit 全局限流 +func NewLocalActiveLimit(maxActive int64) *LocalActiveLimit { + return &LocalActiveLimit{ + maxActive: atomic.NewInt64(maxActive), + countActive: atomic.NewInt64(0), + } +} + +func (a *LocalActiveLimit) SetMaxActive(maxActive int64) *LocalActiveLimit { + a.maxActive.Store(maxActive) + return a +} + +func (a *LocalActiveLimit) Build() gin.HandlerFunc { + return func(ctx *gin.Context) { + current := a.countActive.Add(1) + defer func() { + a.countActive.Sub(1) + }() + if current <= a.maxActive.Load() { + ctx.Next() + } else { + ctx.AbortWithStatus(http.StatusTooManyRequests) + } + return + + } +} diff --git a/middlewares/activelimit/locallimit/builder_test.go b/middlewares/activelimit/locallimit/builder_test.go new file mode 100644 index 0000000..0d6518b --- /dev/null +++ b/middlewares/activelimit/locallimit/builder_test.go @@ -0,0 +1,129 @@ +package locallimit + +import ( + "github.com/gin-gonic/gin" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +func TestLocalActiveLimit_Build(t *testing.T) { + + testCases := []struct { + name string + maxCount int64 + getReq func() *http.Request + createMiddleware func(maxActive int64) gin.HandlerFunc + before func(server *gin.Engine) + + after func() + //响应的code + wantCode int + // + interval time.Duration + }{ + { + name: "开启限流,LocalLimit正常操作", + + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return NewLocalActiveLimit(maxActive).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + + }, + after: func() { + + }, + + maxCount: 1, + wantCode: 200, + }, + { + name: "开启限流,LocalLimit 有一个人很久没出来,新请求被限流", + + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return NewLocalActiveLimit(maxActive).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func() { + + }, + + maxCount: 1, + wantCode: http.StatusTooManyRequests, + }, + { + name: "开启限流,LocalLimit 有一个人很久没出来,等待前面的请求退出后,成功通过", + + createMiddleware: func(maxActive int64) gin.HandlerFunc { + return NewLocalActiveLimit(maxActive).Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + after: func() { + + }, + interval: time.Millisecond * 600, + maxCount: 1, + wantCode: http.StatusOK, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + + server := gin.Default() + server.Use(tc.createMiddleware(tc.maxCount)) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 300) + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + go func() { + tc.before(server) + }() + //加延时保证 tc.before 执行 + time.Sleep(time.Millisecond * 10) + + time.Sleep(tc.interval) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + tc.after() + + }) + } + +} diff --git a/middlewares/activelimit/redislimit/builder.go b/middlewares/activelimit/redislimit/builder.go new file mode 100644 index 0000000..f3da2e2 --- /dev/null +++ b/middlewares/activelimit/redislimit/builder.go @@ -0,0 +1,65 @@ +package redislimit + +import ( + "fmt" + "github.com/gin-gonic/gin" + "github.com/redis/go-redis/v9" + "go.uber.org/atomic" + "net/http" +) + +type RedisActiveLimit struct { + //最大限制个数 + maxActive *atomic.Int64 + + //用来记录连接数的key + key string + cmd redis.Cmdable + logFn func(msg any, args ...any) +} + +// NewRedisActiveLimit 全局限流 +func NewRedisActiveLimit(cmd redis.Cmdable, maxActive int64, key string) *RedisActiveLimit { + return &RedisActiveLimit{ + maxActive: atomic.NewInt64(maxActive), + key: key, + cmd: cmd, + logFn: func(msg any, args ...any) { + fmt.Println(fmt.Sprintf("%v 详细信息: %v", msg, args)) + }, + } +} + +func (a *RedisActiveLimit) SetMaxActive(maxActive int64) *RedisActiveLimit { + a.maxActive.Store(maxActive) + return a +} + +func (a *RedisActiveLimit) SetLogFunc(fun func(msg any, args ...any)) *RedisActiveLimit { + a.logFn = fun + return a +} + +func (a *RedisActiveLimit) Build() gin.HandlerFunc { + return func(ctx *gin.Context) { + currentCount, err := a.cmd.Incr(ctx, a.key).Result() + if err != nil { + //为了安全性 直接返回异常 + a.logFn("redis 加一操作", err) + ctx.AbortWithStatus(http.StatusInternalServerError) + return + } + defer func() { + if err = a.cmd.Decr(ctx, a.key).Err(); err != nil { + a.logFn("redis 减一操作", err) + } + }() + if currentCount <= a.maxActive.Load() { + ctx.Next() + } else { + a.logFn("web server ", "限流中..") + ctx.AbortWithStatus(http.StatusTooManyRequests) + } + return + } +} diff --git a/middlewares/activelimit/redislimit/builder_test.go b/middlewares/activelimit/redislimit/builder_test.go new file mode 100644 index 0000000..e6f8f13 --- /dev/null +++ b/middlewares/activelimit/redislimit/builder_test.go @@ -0,0 +1,258 @@ +package redislimit + +import ( + "context" + "errors" + redismocks "github.com/ecodeclub/ginx/internal/mocks" + "github.com/gin-gonic/gin" + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + "net/http" + "net/http/httptest" + "testing" + "time" +) + +func TestRedisActiveLimit_Build(t *testing.T) { + testCases := []struct { + name string + maxCount int64 + key string + mock func(ctrl *gomock.Controller, key string) redis.Cmdable + getReq func() *http.Request + createMiddleware func(redisClient redis.Cmdable) gin.HandlerFunc + before func(server *gin.Engine, key string) + + interval time.Duration + after func(string2 string) (int64, error) + + //响应的code + wantCode int + + //检查退出的时候redis 状态 + afterCount int64 + afterErr error + }{ + { + name: "开启限流,RedisLimit正常操作", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(nil) + res2.SetVal(int64(0)) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) + return redisClient + + }, + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + after: func(string2 string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, + { + name: "开启限流,RedisLimit正常操作,但是减一操作异常", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(errors.New("减一操作异常")) + res2.SetVal(int64(0)) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2) + return redisClient + + }, + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + after: func(string2 string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, + { + name: "开启限流,RedisLimit,有一个人长时间没退出,导致限流", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + //第一个进来的 + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + //第二个进来的 + res := redis.NewIntCmd(context.Background()) + res.SetErr(nil) + res.SetVal(int64(2)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res) + + //第二个人出去,还有一个处理中 + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(nil) + res2.SetVal(int64(1)) + redisClient.EXPECT().Decr(gomock.Any(), key).Return(res2).AnyTimes() + + //res3 := redis.NewIntCmd(context.Background()) + //res3.SetErr(nil) + //res3.SetVal(int64(0)) + //redisClient.EXPECT().Decr(gomock.Any(), key).Return(res3) + + return redisClient + + }, + + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + + interval: time.Millisecond * 20, + after: func(key string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusTooManyRequests, + }, + { + name: "开启限流,RedisLimit,有一个人长时间没退出,等待前面退出后,正常请求....", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + //第一个进来的 + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(nil) + res1.SetVal(int64(1)) + redisClient.EXPECT().Incr(gomock.Any(), key).Times(2).Return(res1) + //第一个人出去 + res2 := redis.NewIntCmd(context.Background()) + res2.SetErr(nil) + res2.SetVal(int64(0)) + redisClient.EXPECT().Decr(gomock.Any(), key).Times(2).Return(res2) + + return redisClient + }, + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + req, err := http.NewRequest(http.MethodGet, "/activelimit3", nil) + require.NoError(t, err) + resp := httptest.NewRecorder() + server.ServeHTTP(resp, req) + assert.Equal(t, 200, resp.Code) + }, + interval: time.Millisecond * 300, + maxCount: 1, + key: "test", + wantCode: http.StatusOK, + }, + { + name: "系统异常", + mock: func(ctrl *gomock.Controller, key string) redis.Cmdable { + //第一个进来的 + redisClient := redismocks.NewMockCmdable(ctrl) + res1 := redis.NewIntCmd(context.Background()) + res1.SetErr(errors.New("redis 异常")) + res1.SetVal(int64(0)) + redisClient.EXPECT().Incr(gomock.Any(), key).Return(res1) + + return redisClient + + }, + + createMiddleware: func(redisClient redis.Cmdable) gin.HandlerFunc { + return NewRedisActiveLimit(redisClient, 1, "test").Build() + }, + getReq: func() *http.Request { + req, err := http.NewRequest(http.MethodGet, "/activelimit", nil) + require.NoError(t, err) + return req + }, + before: func(server *gin.Engine, key string) { + + }, + + interval: time.Millisecond * 20, + after: func(key string) (int64, error) { + return 0, nil + }, + maxCount: 1, + key: "test", + wantCode: http.StatusInternalServerError, + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ctl := gomock.NewController(t) + defer ctl.Finish() + server := gin.Default() + server.Use(tc.createMiddleware(tc.mock(ctl, tc.key))) + server.GET("/activelimit", func(ctx *gin.Context) { + ctx.Status(http.StatusOK) + }) + server.GET("/activelimit3", func(ctx *gin.Context) { + time.Sleep(time.Millisecond * 100) + ctx.Status(http.StatusOK) + }) + resp := httptest.NewRecorder() + go func() { + tc.before(server, tc.key) + }() + time.Sleep(tc.interval) + server.ServeHTTP(resp, tc.getReq()) + assert.Equal(t, tc.wantCode, resp.Code) + + }) + } +}