From 54acfa8880b6b024de1ac43a33dec24dea22ce82 Mon Sep 17 00:00:00 2001 From: Victoria Nadasdi Date: Mon, 20 May 2024 19:13:42 +0200 Subject: [PATCH] refactor: redis queue backend test cleanup Summary: - Move existing test under a `testify` Suite as `baseRedisWithServerTestSuite` - Those tests require real redis server. - Add `go.uber.org/mock/mockgen@latest` as dependency - as a tool (Makefile). - in the `go.mod` file. - Mock redis client lives under a `mock` directory under the queue module. - That mock module has an extra hand-written mock in-memory redis-like struct. - Add tests using the mock redis client. - Changed the logic around queue provider creation. - Now the `getNewQueue` returns a Queue provider directly, not an init function to create it. The whole Queue module is close to impossible to test properly because everything is private, everything goes through a struct route. Because of that, we can't test for example what keys are used for given queue. To overcome this, as a first step I removed one step from that hard route by allowing custom calls to create new queue provider. To achieve this, I moved the creation logic into the `getNewQueue` (previously it was `getNewQueueFn`). That changes nothing on that side, everything goes as before, except the `newXXX` call happens directly in that function and not outside that. That made it possible to add extra provider specific parameters to those function (`newXXX`). For example a client on redis. Calling it through the `getNewQueue` function, it gets `nil`. - If the provided client is not `nil`, it will use that instead of the connection string. - If it's `nil` (default behaviour), it creates a new redis client as it did before, no changes to that. The rest of the provider code is unchanged. All these changes were required to make it possible to generate mock clients for providers and use them. For the tests, the existing two test cases are good with redis server, and they need some extra helpers, for example to start a new redis server if required, or waiting on a redis server to be ready to use. These helpers are only required for test cases using real redis server. For better isolation, moved existing test under a testify Suite, and moved them into a new test file called `base_redis_with_server_test.go` because, well they test the code with server. These tests do exactly the same as before, calling the same sub-tests the same way as before, the only change is the structure of the test (remove repetition, scope server related helper functions). Finally, we can create unit tests without redis server. The main focus of this group of tests are higher level overview of operations. With the mock redis client we can set up expectations about used queue names, received values, return value to simulate faulty state. These new unit test functions don't test all functionality, at least it's not aimed for it now. It's more about the possibility of doing that and add extra tests around parts we couldn't test before, for example key. What extra features can test the new unit test group: - What is the received key for given queue? For example using `prefix`, or if all the `SXxx` calls are expected to use `queue_unique` if it's a unique queue. - If it's not a unique queue, no `SXxx` functions are called, because those sets are used only to check if a value is unique or not. - `HasItem` return `false` always if it's a non-unique queue. - All functions are called exactly `N` times, and we don't have any unexpected calls to redis from the code. Signed-off-by: Victoria Nadasdi --- Makefile | 3 + go.mod | 1 + go.sum | 2 + modules/queue/base_redis.go | 11 +- modules/queue/base_redis_test.go | 222 +- modules/queue/base_redis_with_server_test.go | 132 + modules/queue/mock/inmemorymockredis.go | 133 + modules/queue/mock/redisuniversalclient.go | 7168 ++++++++++++++++++ modules/queue/workerqueue.go | 26 +- 9 files changed, 7581 insertions(+), 117 deletions(-) create mode 100644 modules/queue/base_redis_with_server_test.go create mode 100644 modules/queue/mock/inmemorymockredis.go create mode 100644 modules/queue/mock/redisuniversalclient.go diff --git a/Makefile b/Makefile index 1cdc550d29..72757da883 100644 --- a/Makefile +++ b/Makefile @@ -38,6 +38,7 @@ GO_LICENSES_PACKAGE ?= github.com/google/go-licenses@v1.6.0 # renovate: datasour GOVULNCHECK_PACKAGE ?= golang.org/x/vuln/cmd/govulncheck@v1 # renovate: datasource=go ACTIONLINT_PACKAGE ?= github.com/rhysd/actionlint/cmd/actionlint@v1.6.27 # renovate: datasource=go DEADCODE_PACKAGE ?= golang.org/x/tools/internal/cmd/deadcode@v0.14.0 # renovate: datasource=go +GOMOCK_PACKAGE ?= go.uber.org/mock/mockgen@latest DOCKER_IMAGE ?= gitea/gitea DOCKER_TAG ?= latest @@ -783,6 +784,7 @@ generate-backend: $(TAGS_PREREQ) generate-go generate-go: $(TAGS_PREREQ) @echo "Running go generate..." @CC= GOOS= GOARCH= CGO_ENABLED=0 $(GO) generate -tags '$(TAGS)' ./... + $(GO) run $(GOMOCK_PACKAGE) -package mock -destination ./modules/queue/mock/redisuniversalclient.go github.com/redis/go-redis/v9 UniversalClient .PHONY: merge-locales merge-locales: @@ -884,6 +886,7 @@ deps-tools: $(GO) install $(GO_LICENSES_PACKAGE) $(GO) install $(GOVULNCHECK_PACKAGE) $(GO) install $(ACTIONLINT_PACKAGE) + $(GO) install $(GOMOCK_PACKAGE) node_modules: package-lock.json npm install --no-save diff --git a/go.mod b/go.mod index c5337b2d8f..3ba5b20c5c 100644 --- a/go.mod +++ b/go.mod @@ -281,6 +281,7 @@ require ( go.opentelemetry.io/otel v1.22.0 // indirect go.opentelemetry.io/otel/trace v1.22.0 // indirect go.uber.org/atomic v1.11.0 // indirect + go.uber.org/mock v0.4.0 // indirect go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.27.0 // indirect golang.org/x/exp v0.0.0-20240119083558-1b970713d09a // indirect diff --git a/go.sum b/go.sum index 3a25bc3ad5..27777310e5 100644 --- a/go.sum +++ b/go.sum @@ -877,6 +877,8 @@ go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0 go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= diff --git a/modules/queue/base_redis.go b/modules/queue/base_redis.go index abab0f5c5e..14931b62cd 100644 --- a/modules/queue/base_redis.go +++ b/modules/queue/base_redis.go @@ -26,8 +26,11 @@ type baseRedis struct { var _ baseQueue = (*baseRedis)(nil) -func newBaseRedisGeneric(cfg *BaseConfig, unique bool) (baseQueue, error) { - client := nosql.GetManager().GetRedisClient(cfg.ConnStr) +func newBaseRedisGeneric(cfg *BaseConfig, unique bool, client redis.UniversalClient) (baseQueue, error) { + if client == nil { + client = nosql.GetManager().GetRedisClient(cfg.ConnStr) + } + prefix := "" uri := nosql.ToRedisURI(cfg.ConnStr) @@ -62,11 +65,11 @@ func newBaseRedisGeneric(cfg *BaseConfig, unique bool) (baseQueue, error) { } func newBaseRedisSimple(cfg *BaseConfig) (baseQueue, error) { - return newBaseRedisGeneric(cfg, false) + return newBaseRedisGeneric(cfg, false, nil) } func newBaseRedisUnique(cfg *BaseConfig) (baseQueue, error) { - return newBaseRedisGeneric(cfg, true) + return newBaseRedisGeneric(cfg, true, nil) } func (q *baseRedis) prefixedName(name string) string { diff --git a/modules/queue/base_redis_test.go b/modules/queue/base_redis_test.go index ed01a990ba..04e200c3f7 100644 --- a/modules/queue/base_redis_test.go +++ b/modules/queue/base_redis_test.go @@ -5,120 +5,134 @@ package queue import ( "context" - "os" - "os/exec" "testing" - "time" - "code.gitea.io/gitea/modules/nosql" + "code.gitea.io/gitea/modules/queue/mock" "code.gitea.io/gitea/modules/setting" - "github.com/stretchr/testify/assert" + "github.com/redis/go-redis/v9" + "github.com/stretchr/testify/suite" + "go.uber.org/mock/gomock" ) -const defaultTestRedisServer = "127.0.0.1:6379" +type baseRedisUnitTestSuite struct { + suite.Suite -func testRedisHost() string { - value := os.Getenv("TEST_REDIS_SERVER") - if value != "" { - return value - } - - return defaultTestRedisServer -} - -func waitRedisReady(conn string, dur time.Duration) (ready bool) { - ctxTimed, cancel := context.WithTimeout(context.Background(), time.Second*5) - defer cancel() - for t := time.Now(); ; time.Sleep(50 * time.Millisecond) { - ret := nosql.GetManager().GetRedisClient(conn).Ping(ctxTimed) - if ret.Err() == nil { - return true - } - if time.Since(t) > dur { - return false - } - } -} - -func redisServerCmd(t *testing.T) *exec.Cmd { - redisServerProg, err := exec.LookPath("redis-server") - if err != nil { - return nil - } - c := &exec.Cmd{ - Path: redisServerProg, - Args: []string{redisServerProg, "--bind", "127.0.0.1", "--port", "6379"}, - Dir: t.TempDir(), - Stdin: os.Stdin, - Stdout: os.Stdout, - Stderr: os.Stderr, - } - return c + mockController *gomock.Controller } func TestBaseRedis(t *testing.T) { - redisAddress := "redis://" + testRedisHost() + "/0" - queueSettings := setting.QueueSettings{ - Length: 10, - ConnStr: redisAddress, - } - - var redisServer *exec.Cmd - if !waitRedisReady(redisAddress, 0) { - redisServer = redisServerCmd(t) - - if redisServer == nil { - t.Skip("redis-server not found in Forgejo test yet") - return - } - - assert.NoError(t, redisServer.Start()) - if !assert.True(t, waitRedisReady(redisAddress, 5*time.Second), "start redis-server") { - return - } - } - - defer func() { - if redisServer != nil { - _ = redisServer.Process.Signal(os.Interrupt) - _ = redisServer.Wait() - } - }() - - testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", queueSettings), false) - testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", queueSettings), true) + suite.Run(t, &baseRedisUnitTestSuite{}) } -func TestBaseRedisWithPrefix(t *testing.T) { - redisAddress := "redis://" + testRedisHost() + "/0?prefix=forgejo:queue:" - queueSettings := setting.QueueSettings{ - Length: 10, - ConnStr: redisAddress, - } - - var redisServer *exec.Cmd - if !waitRedisReady(redisAddress, 0) { - redisServer = redisServerCmd(t) - - if redisServer == nil { - t.Skip("redis-server not found in Forgejo test yet") - return - } - - assert.NoError(t, redisServer.Start()) - if !assert.True(t, waitRedisReady(redisAddress, 5*time.Second), "start redis-server") { - return - } - } - - defer func() { - if redisServer != nil { - _ = redisServer.Process.Signal(os.Interrupt) - _ = redisServer.Wait() - } - }() - - testQueueBasic(t, newBaseRedisSimple, toBaseConfig("baseRedis", queueSettings), false) - testQueueBasic(t, newBaseRedisUnique, toBaseConfig("baseRedisUnique", queueSettings), true) +func (suite *baseRedisUnitTestSuite) SetupSuite() { + suite.mockController = gomock.NewController(suite.T()) +} + +func (suite *baseRedisUnitTestSuite) TestBasic() { + queueName := "test-queue" + testCases := []struct { + Name string + ConnectionString string + QueueName string + Unique bool + }{ + { + Name: "unique", + ConnectionString: "redis://127.0.0.1/0", + QueueName: queueName, + Unique: true, + }, + { + Name: "non-unique", + ConnectionString: "redis://127.0.0.1/0", + QueueName: queueName, + Unique: false, + }, + { + Name: "unique with prefix", + ConnectionString: "redis://127.0.0.1/0?prefix=forgejo:queue:", + QueueName: "forgejo:queue:" + queueName, + Unique: true, + }, + { + Name: "non-unique with prefix", + ConnectionString: "redis://127.0.0.1/0?prefix=forgejo:queue:", + QueueName: "forgejo:queue:" + queueName, + Unique: false, + }, + } + + for _, testCase := range testCases { + suite.Run(testCase.Name, func() { + queueSettings := setting.QueueSettings{ + Length: 10, + ConnStr: testCase.ConnectionString, + } + + // Configure expectations. + mockRedisStore := mock.NewInMemoryMockRedis() + redisClient := mock.NewMockUniversalClient(suite.mockController) + + redisClient.EXPECT(). + Ping(gomock.Any()). + Times(1). + Return(&redis.StatusCmd{}) + redisClient.EXPECT(). + LLen(gomock.Any(), testCase.QueueName). + Times(1). + DoAndReturn(mockRedisStore.LLen) + redisClient.EXPECT(). + LPop(gomock.Any(), testCase.QueueName). + Times(1). + DoAndReturn(mockRedisStore.LPop) + redisClient.EXPECT(). + RPush(gomock.Any(), testCase.QueueName, gomock.Any()). + Times(1). + DoAndReturn(mockRedisStore.RPush) + + if testCase.Unique { + redisClient.EXPECT(). + SAdd(gomock.Any(), testCase.QueueName+"_unique", gomock.Any()). + Times(1). + DoAndReturn(mockRedisStore.SAdd) + redisClient.EXPECT(). + SRem(gomock.Any(), testCase.QueueName+"_unique", gomock.Any()). + Times(1). + DoAndReturn(mockRedisStore.SRem) + redisClient.EXPECT(). + SIsMember(gomock.Any(), testCase.QueueName+"_unique", gomock.Any()). + Times(2). + DoAndReturn(mockRedisStore.SIsMember) + } + + client, err := newBaseRedisGeneric( + toBaseConfig(queueName, queueSettings), + testCase.Unique, + redisClient, + ) + suite.Require().NoError(err) + + ctx := context.Background() + expectedContent := []byte("test") + + suite.Require().NoError(client.PushItem(ctx, expectedContent)) + + found, err := client.HasItem(ctx, expectedContent) + suite.Require().NoError(err) + if testCase.Unique { + suite.True(found) + } else { + suite.False(found) + } + + found, err = client.HasItem(ctx, []byte("not found content")) + suite.Require().NoError(err) + suite.False(found) + + content, err := client.PopItem(ctx) + suite.Require().NoError(err) + suite.Equal(expectedContent, content) + }) + } } diff --git a/modules/queue/base_redis_with_server_test.go b/modules/queue/base_redis_with_server_test.go new file mode 100644 index 0000000000..5c09c02810 --- /dev/null +++ b/modules/queue/base_redis_with_server_test.go @@ -0,0 +1,132 @@ +package queue + +import ( + "context" + "os" + "os/exec" + "testing" + "time" + + "code.gitea.io/gitea/modules/nosql" + "code.gitea.io/gitea/modules/setting" + "github.com/stretchr/testify/suite" +) + +const defaultTestRedisServer = "127.0.0.1:6379" + +type baseRedisWithServerTestSuite struct { + suite.Suite +} + +func TestBaseRedisWithServer(t *testing.T) { + suite.Run(t, &baseRedisWithServerTestSuite{}) +} + +func (suite *baseRedisWithServerTestSuite) TestNormal() { + redisAddress := "redis://" + suite.testRedisHost() + "/0" + queueSettings := setting.QueueSettings{ + Length: 10, + ConnStr: redisAddress, + } + + redisServer, accessible := suite.startRedisServer(redisAddress) + + // If it's accessible, but redisServer command is nil, that means we are using + // an already running redis server. + if redisServer == nil && !accessible { + suite.T().Skip("redis-server not found in Forgejo test yet") + + return + } + + defer func() { + if redisServer != nil { + _ = redisServer.Process.Signal(os.Interrupt) + _ = redisServer.Wait() + } + }() + + testQueueBasic(suite.T(), newBaseRedisSimple, toBaseConfig("baseRedis", queueSettings), false) + testQueueBasic(suite.T(), newBaseRedisUnique, toBaseConfig("baseRedisUnique", queueSettings), true) +} + +func (suite *baseRedisWithServerTestSuite) TestWithPrefix() { + redisAddress := "redis://" + suite.testRedisHost() + "/0?prefix=forgejo:queue:" + queueSettings := setting.QueueSettings{ + Length: 10, + ConnStr: redisAddress, + } + + redisServer, accessible := suite.startRedisServer(redisAddress) + + // If it's accessible, but redisServer command is nil, that means we are using + // an already running redis server. + if redisServer == nil && !accessible { + suite.T().Skip("redis-server not found in Forgejo test yet") + + return + } + + defer func() { + if redisServer != nil { + _ = redisServer.Process.Signal(os.Interrupt) + _ = redisServer.Wait() + } + }() + + testQueueBasic(suite.T(), newBaseRedisSimple, toBaseConfig("baseRedis", queueSettings), false) + testQueueBasic(suite.T(), newBaseRedisUnique, toBaseConfig("baseRedisUnique", queueSettings), true) +} + +func (suite *baseRedisWithServerTestSuite) startRedisServer(address string) (*exec.Cmd, bool) { + var redisServer *exec.Cmd + + if !suite.waitRedisReady(address, 0) { + redisServerProg, err := exec.LookPath("redis-server") + if err != nil { + return nil, false + } + redisServer = &exec.Cmd{ + Path: redisServerProg, + Args: []string{redisServerProg, "--bind", "127.0.0.1", "--port", "6379"}, + Dir: suite.T().TempDir(), + Stdin: os.Stdin, + Stdout: os.Stdout, + Stderr: os.Stderr, + } + + suite.Require().NoError(redisServer.Start()) + + if !suite.True(suite.waitRedisReady(address, 5*time.Second), "start redis-server") { + // Return with redis server even if it's not available. It was started, + // even if it's not reachable for any reasons, it's still started, the + // parent will close it. + return redisServer, false + } + } + + return redisServer, true +} + +func (suite *baseRedisWithServerTestSuite) waitRedisReady(conn string, dur time.Duration) (ready bool) { + ctxTimed, cancel := context.WithTimeout(context.Background(), time.Second*5) + defer cancel() + for t := time.Now(); ; time.Sleep(50 * time.Millisecond) { + ret := nosql.GetManager().GetRedisClient(conn).Ping(ctxTimed) + if ret.Err() == nil { + return true + } + if time.Since(t) > dur { + return false + } + } +} + +func (suite *baseRedisWithServerTestSuite) testRedisHost() string { + value := os.Getenv("TEST_REDIS_SERVER") + if value != "" { + return value + } + + return defaultTestRedisServer +} diff --git a/modules/queue/mock/inmemorymockredis.go b/modules/queue/mock/inmemorymockredis.go new file mode 100644 index 0000000000..de8bd8a0fd --- /dev/null +++ b/modules/queue/mock/inmemorymockredis.go @@ -0,0 +1,133 @@ +package mock + +import ( + "context" + "errors" + + redis "github.com/redis/go-redis/v9" +) + +// InMemoryMockRedis is a very primitive in-memory redis-like feature. The main +// purpose of this struct is to give some backend to mocked unit tests. +type InMemoryMockRedis struct { + queues map[string][][]byte +} + +func NewInMemoryMockRedis() InMemoryMockRedis { + return InMemoryMockRedis{ + queues: map[string][][]byte{}, + } +} + +func (r *InMemoryMockRedis) LLen(ctx context.Context, key string) *redis.IntCmd { + cmd := redis.NewIntCmd(ctx) + cmd.SetVal(int64(len(r.queues[key]))) + return cmd +} + +func (r *InMemoryMockRedis) SAdd(ctx context.Context, key string, content []byte) *redis.IntCmd { + cmd := redis.NewIntCmd(ctx) + + for _, value := range r.queues[key] { + if string(value) == string(content) { + cmd.SetVal(0) + + return cmd + } + } + + r.queues[key] = append(r.queues[key], content) + + cmd.SetVal(1) + + return cmd +} + +func (r *InMemoryMockRedis) RPush(ctx context.Context, key string, content []byte) *redis.IntCmd { + cmd := redis.NewIntCmd(ctx) + + r.queues[key] = append(r.queues[key], content) + + cmd.SetVal(1) + + return cmd +} + +func (r *InMemoryMockRedis) LPop(ctx context.Context, key string) *redis.StringCmd { + cmd := redis.NewStringCmd(ctx) + + queue, found := r.queues[key] + if !found { + cmd.SetErr(errors.New("queue not found")) + + return cmd + } + + if len(queue) < 1 { + cmd.SetErr(errors.New("queue is empty")) + + return cmd + } + + value, rest := queue[0], queue[1:] + + r.queues[key] = rest + + cmd.SetVal(string(value)) + + return cmd +} + +func (r *InMemoryMockRedis) SRem(ctx context.Context, key string, content []byte) *redis.IntCmd { + cmd := redis.NewIntCmd(ctx) + + queue, found := r.queues[key] + if !found { + cmd.SetErr(errors.New("queue not found")) + + return cmd + } + + if len(queue) < 1 { + cmd.SetErr(errors.New("queue is empty")) + + return cmd + } + + newList := [][]byte{} + + for _, value := range queue { + if string(value) != string(content) { + newList = append(newList, value) + } + } + + r.queues[key] = newList + + cmd.SetVal(1) + + return cmd +} + +func (r *InMemoryMockRedis) SIsMember(ctx context.Context, key string, content []byte) *redis.BoolCmd { + cmd := redis.NewBoolCmd(ctx) + + queue, found := r.queues[key] + if !found { + cmd.SetErr(errors.New("queue not found")) + + return cmd + } + + for _, value := range queue { + if string(value) == string(content) { + cmd.SetVal(true) + + return cmd + } + } + + cmd.SetVal(false) + + return cmd +} diff --git a/modules/queue/mock/redisuniversalclient.go b/modules/queue/mock/redisuniversalclient.go new file mode 100644 index 0000000000..ea647480e6 --- /dev/null +++ b/modules/queue/mock/redisuniversalclient.go @@ -0,0 +1,7168 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/redis/go-redis/v9 (interfaces: UniversalClient) +// +// Generated by this command: +// +// mockgen -package mock -destination ./modules/queue/mock/redisuniversalclient.go github.com/redis/go-redis/v9 UniversalClient +// + +// Package mock is a generated GoMock package. +package mock + +import ( + context "context" + reflect "reflect" + time "time" + + redis "github.com/redis/go-redis/v9" + gomock "go.uber.org/mock/gomock" +) + +// MockUniversalClient is a mock of UniversalClient interface. +type MockUniversalClient struct { + ctrl *gomock.Controller + recorder *MockUniversalClientMockRecorder +} + +// MockUniversalClientMockRecorder is the mock recorder for MockUniversalClient. +type MockUniversalClientMockRecorder struct { + mock *MockUniversalClient +} + +// NewMockUniversalClient creates a new mock instance. +func NewMockUniversalClient(ctrl *gomock.Controller) *MockUniversalClient { + mock := &MockUniversalClient{ctrl: ctrl} + mock.recorder = &MockUniversalClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockUniversalClient) EXPECT() *MockUniversalClientMockRecorder { + return m.recorder +} + +// ACLDryRun mocks base method. +func (m *MockUniversalClient) ACLDryRun(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ACLDryRun", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ACLDryRun indicates an expected call of ACLDryRun. +func (mr *MockUniversalClientMockRecorder) ACLDryRun(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLDryRun", reflect.TypeOf((*MockUniversalClient)(nil).ACLDryRun), varargs...) +} + +// ACLLog mocks base method. +func (m *MockUniversalClient) ACLLog(arg0 context.Context, arg1 int64) *redis.ACLLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLog", arg0, arg1) + ret0, _ := ret[0].(*redis.ACLLogCmd) + return ret0 +} + +// ACLLog indicates an expected call of ACLLog. +func (mr *MockUniversalClientMockRecorder) ACLLog(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockUniversalClient)(nil).ACLLog), arg0, arg1) +} + +// ACLLogReset mocks base method. +func (m *MockUniversalClient) ACLLogReset(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ACLLogReset", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ACLLogReset indicates an expected call of ACLLogReset. +func (mr *MockUniversalClientMockRecorder) ACLLogReset(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockUniversalClient)(nil).ACLLogReset), arg0) +} + +// AddHook mocks base method. +func (m *MockUniversalClient) AddHook(arg0 redis.Hook) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "AddHook", arg0) +} + +// AddHook indicates an expected call of AddHook. +func (mr *MockUniversalClientMockRecorder) AddHook(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHook", reflect.TypeOf((*MockUniversalClient)(nil).AddHook), arg0) +} + +// Append mocks base method. +func (m *MockUniversalClient) Append(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Append", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Append indicates an expected call of Append. +func (mr *MockUniversalClientMockRecorder) Append(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockUniversalClient)(nil).Append), arg0, arg1, arg2) +} + +// BFAdd mocks base method. +func (m *MockUniversalClient) BFAdd(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFAdd", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFAdd indicates an expected call of BFAdd. +func (mr *MockUniversalClientMockRecorder) BFAdd(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockUniversalClient)(nil).BFAdd), arg0, arg1, arg2) +} + +// BFCard mocks base method. +func (m *MockUniversalClient) BFCard(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFCard", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BFCard indicates an expected call of BFCard. +func (mr *MockUniversalClientMockRecorder) BFCard(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockUniversalClient)(nil).BFCard), arg0, arg1) +} + +// BFExists mocks base method. +func (m *MockUniversalClient) BFExists(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFExists", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// BFExists indicates an expected call of BFExists. +func (mr *MockUniversalClientMockRecorder) BFExists(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockUniversalClient)(nil).BFExists), arg0, arg1, arg2) +} + +// BFInfo mocks base method. +func (m *MockUniversalClient) BFInfo(arg0 context.Context, arg1 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfo indicates an expected call of BFInfo. +func (mr *MockUniversalClientMockRecorder) BFInfo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockUniversalClient)(nil).BFInfo), arg0, arg1) +} + +// BFInfoArg mocks base method. +func (m *MockUniversalClient) BFInfoArg(arg0 context.Context, arg1, arg2 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoArg", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoArg indicates an expected call of BFInfoArg. +func (mr *MockUniversalClientMockRecorder) BFInfoArg(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoArg), arg0, arg1, arg2) +} + +// BFInfoCapacity mocks base method. +func (m *MockUniversalClient) BFInfoCapacity(arg0 context.Context, arg1 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoCapacity", arg0, arg1) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoCapacity indicates an expected call of BFInfoCapacity. +func (mr *MockUniversalClientMockRecorder) BFInfoCapacity(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoCapacity), arg0, arg1) +} + +// BFInfoExpansion mocks base method. +func (m *MockUniversalClient) BFInfoExpansion(arg0 context.Context, arg1 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoExpansion", arg0, arg1) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoExpansion indicates an expected call of BFInfoExpansion. +func (mr *MockUniversalClientMockRecorder) BFInfoExpansion(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoExpansion), arg0, arg1) +} + +// BFInfoFilters mocks base method. +func (m *MockUniversalClient) BFInfoFilters(arg0 context.Context, arg1 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoFilters", arg0, arg1) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoFilters indicates an expected call of BFInfoFilters. +func (mr *MockUniversalClientMockRecorder) BFInfoFilters(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoFilters), arg0, arg1) +} + +// BFInfoItems mocks base method. +func (m *MockUniversalClient) BFInfoItems(arg0 context.Context, arg1 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoItems", arg0, arg1) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoItems indicates an expected call of BFInfoItems. +func (mr *MockUniversalClientMockRecorder) BFInfoItems(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoItems), arg0, arg1) +} + +// BFInfoSize mocks base method. +func (m *MockUniversalClient) BFInfoSize(arg0 context.Context, arg1 string) *redis.BFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFInfoSize", arg0, arg1) + ret0, _ := ret[0].(*redis.BFInfoCmd) + return ret0 +} + +// BFInfoSize indicates an expected call of BFInfoSize. +func (mr *MockUniversalClientMockRecorder) BFInfoSize(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockUniversalClient)(nil).BFInfoSize), arg0, arg1) +} + +// BFInsert mocks base method. +func (m *MockUniversalClient) BFInsert(arg0 context.Context, arg1 string, arg2 *redis.BFInsertOptions, arg3 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFInsert indicates an expected call of BFInsert. +func (mr *MockUniversalClientMockRecorder) BFInsert(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInsert", reflect.TypeOf((*MockUniversalClient)(nil).BFInsert), varargs...) +} + +// BFLoadChunk mocks base method. +func (m *MockUniversalClient) BFLoadChunk(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFLoadChunk", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFLoadChunk indicates an expected call of BFLoadChunk. +func (mr *MockUniversalClientMockRecorder) BFLoadChunk(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockUniversalClient)(nil).BFLoadChunk), arg0, arg1, arg2, arg3) +} + +// BFMAdd mocks base method. +func (m *MockUniversalClient) BFMAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMAdd", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMAdd indicates an expected call of BFMAdd. +func (mr *MockUniversalClientMockRecorder) BFMAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMAdd", reflect.TypeOf((*MockUniversalClient)(nil).BFMAdd), varargs...) +} + +// BFMExists mocks base method. +func (m *MockUniversalClient) BFMExists(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// BFMExists indicates an expected call of BFMExists. +func (mr *MockUniversalClientMockRecorder) BFMExists(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFMExists", reflect.TypeOf((*MockUniversalClient)(nil).BFMExists), varargs...) +} + +// BFReserve mocks base method. +func (m *MockUniversalClient) BFReserve(arg0 context.Context, arg1 string, arg2 float64, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserve", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserve indicates an expected call of BFReserve. +func (mr *MockUniversalClientMockRecorder) BFReserve(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockUniversalClient)(nil).BFReserve), arg0, arg1, arg2, arg3) +} + +// BFReserveExpansion mocks base method. +func (m *MockUniversalClient) BFReserveExpansion(arg0 context.Context, arg1 string, arg2 float64, arg3, arg4 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveExpansion", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveExpansion indicates an expected call of BFReserveExpansion. +func (mr *MockUniversalClientMockRecorder) BFReserveExpansion(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveExpansion), arg0, arg1, arg2, arg3, arg4) +} + +// BFReserveNonScaling mocks base method. +func (m *MockUniversalClient) BFReserveNonScaling(arg0 context.Context, arg1 string, arg2 float64, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveNonScaling", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveNonScaling indicates an expected call of BFReserveNonScaling. +func (mr *MockUniversalClientMockRecorder) BFReserveNonScaling(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveNonScaling), arg0, arg1, arg2, arg3) +} + +// BFReserveWithArgs mocks base method. +func (m *MockUniversalClient) BFReserveWithArgs(arg0 context.Context, arg1 string, arg2 *redis.BFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFReserveWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BFReserveWithArgs indicates an expected call of BFReserveWithArgs. +func (mr *MockUniversalClientMockRecorder) BFReserveWithArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).BFReserveWithArgs), arg0, arg1, arg2) +} + +// BFScanDump mocks base method. +func (m *MockUniversalClient) BFScanDump(arg0 context.Context, arg1 string, arg2 int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BFScanDump", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// BFScanDump indicates an expected call of BFScanDump. +func (mr *MockUniversalClientMockRecorder) BFScanDump(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockUniversalClient)(nil).BFScanDump), arg0, arg1, arg2) +} + +// BLMPop mocks base method. +func (m *MockUniversalClient) BLMPop(arg0 context.Context, arg1 time.Duration, arg2 string, arg3 int64, arg4 ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2, arg3} + for _, a := range arg4 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// BLMPop indicates an expected call of BLMPop. +func (mr *MockUniversalClientMockRecorder) BLMPop(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMPop", reflect.TypeOf((*MockUniversalClient)(nil).BLMPop), varargs...) +} + +// BLMove mocks base method. +func (m *MockUniversalClient) BLMove(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BLMove", arg0, arg1, arg2, arg3, arg4, arg5) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BLMove indicates an expected call of BLMove. +func (mr *MockUniversalClientMockRecorder) BLMove(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLMove", reflect.TypeOf((*MockUniversalClient)(nil).BLMove), arg0, arg1, arg2, arg3, arg4, arg5) +} + +// BLPop mocks base method. +func (m *MockUniversalClient) BLPop(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BLPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BLPop indicates an expected call of BLPop. +func (mr *MockUniversalClientMockRecorder) BLPop(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockUniversalClient)(nil).BLPop), varargs...) +} + +// BRPop mocks base method. +func (m *MockUniversalClient) BRPop(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BRPop", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// BRPop indicates an expected call of BRPop. +func (mr *MockUniversalClientMockRecorder) BRPop(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockUniversalClient)(nil).BRPop), varargs...) +} + +// BRPopLPush mocks base method. +func (m *MockUniversalClient) BRPopLPush(arg0 context.Context, arg1, arg2 string, arg3 time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BRPopLPush", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// BRPopLPush indicates an expected call of BRPopLPush. +func (mr *MockUniversalClientMockRecorder) BRPopLPush(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockUniversalClient)(nil).BRPopLPush), arg0, arg1, arg2, arg3) +} + +// BZMPop mocks base method. +func (m *MockUniversalClient) BZMPop(arg0 context.Context, arg1 time.Duration, arg2 string, arg3 int64, arg4 ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2, arg3} + for _, a := range arg4 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// BZMPop indicates an expected call of BZMPop. +func (mr *MockUniversalClientMockRecorder) BZMPop(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZMPop", reflect.TypeOf((*MockUniversalClient)(nil).BZMPop), varargs...) +} + +// BZPopMax mocks base method. +func (m *MockUniversalClient) BZPopMax(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMax indicates an expected call of BZPopMax. +func (mr *MockUniversalClientMockRecorder) BZPopMax(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockUniversalClient)(nil).BZPopMax), varargs...) +} + +// BZPopMin mocks base method. +func (m *MockUniversalClient) BZPopMin(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.ZWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZWithKeyCmd) + return ret0 +} + +// BZPopMin indicates an expected call of BZPopMin. +func (mr *MockUniversalClientMockRecorder) BZPopMin(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockUniversalClient)(nil).BZPopMin), varargs...) +} + +// BgRewriteAOF mocks base method. +func (m *MockUniversalClient) BgRewriteAOF(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgRewriteAOF", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgRewriteAOF indicates an expected call of BgRewriteAOF. +func (mr *MockUniversalClientMockRecorder) BgRewriteAOF(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockUniversalClient)(nil).BgRewriteAOF), arg0) +} + +// BgSave mocks base method. +func (m *MockUniversalClient) BgSave(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BgSave", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// BgSave indicates an expected call of BgSave. +func (mr *MockUniversalClientMockRecorder) BgSave(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockUniversalClient)(nil).BgSave), arg0) +} + +// BitCount mocks base method. +func (m *MockUniversalClient) BitCount(arg0 context.Context, arg1 string, arg2 *redis.BitCount) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitCount", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitCount indicates an expected call of BitCount. +func (mr *MockUniversalClientMockRecorder) BitCount(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockUniversalClient)(nil).BitCount), arg0, arg1, arg2) +} + +// BitField mocks base method. +func (m *MockUniversalClient) BitField(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitField", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// BitField indicates an expected call of BitField. +func (mr *MockUniversalClientMockRecorder) BitField(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockUniversalClient)(nil).BitField), varargs...) +} + +// BitOpAnd mocks base method. +func (m *MockUniversalClient) BitOpAnd(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpAnd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpAnd indicates an expected call of BitOpAnd. +func (mr *MockUniversalClientMockRecorder) BitOpAnd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockUniversalClient)(nil).BitOpAnd), varargs...) +} + +// BitOpNot mocks base method. +func (m *MockUniversalClient) BitOpNot(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitOpNot", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpNot indicates an expected call of BitOpNot. +func (mr *MockUniversalClientMockRecorder) BitOpNot(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockUniversalClient)(nil).BitOpNot), arg0, arg1, arg2) +} + +// BitOpOr mocks base method. +func (m *MockUniversalClient) BitOpOr(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpOr", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpOr indicates an expected call of BitOpOr. +func (mr *MockUniversalClientMockRecorder) BitOpOr(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockUniversalClient)(nil).BitOpOr), varargs...) +} + +// BitOpXor mocks base method. +func (m *MockUniversalClient) BitOpXor(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitOpXor", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitOpXor indicates an expected call of BitOpXor. +func (mr *MockUniversalClientMockRecorder) BitOpXor(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockUniversalClient)(nil).BitOpXor), varargs...) +} + +// BitPos mocks base method. +func (m *MockUniversalClient) BitPos(arg0 context.Context, arg1 string, arg2 int64, arg3 ...int64) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BitPos", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPos indicates an expected call of BitPos. +func (mr *MockUniversalClientMockRecorder) BitPos(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockUniversalClient)(nil).BitPos), varargs...) +} + +// BitPosSpan mocks base method. +func (m *MockUniversalClient) BitPosSpan(arg0 context.Context, arg1 string, arg2 int8, arg3, arg4 int64, arg5 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BitPosSpan", arg0, arg1, arg2, arg3, arg4, arg5) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// BitPosSpan indicates an expected call of BitPosSpan. +func (mr *MockUniversalClientMockRecorder) BitPosSpan(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockUniversalClient)(nil).BitPosSpan), arg0, arg1, arg2, arg3, arg4, arg5) +} + +// CFAdd mocks base method. +func (m *MockUniversalClient) CFAdd(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAdd", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAdd indicates an expected call of CFAdd. +func (mr *MockUniversalClientMockRecorder) CFAdd(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockUniversalClient)(nil).CFAdd), arg0, arg1, arg2) +} + +// CFAddNX mocks base method. +func (m *MockUniversalClient) CFAddNX(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFAddNX", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFAddNX indicates an expected call of CFAddNX. +func (mr *MockUniversalClientMockRecorder) CFAddNX(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockUniversalClient)(nil).CFAddNX), arg0, arg1, arg2) +} + +// CFCount mocks base method. +func (m *MockUniversalClient) CFCount(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFCount", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// CFCount indicates an expected call of CFCount. +func (mr *MockUniversalClientMockRecorder) CFCount(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockUniversalClient)(nil).CFCount), arg0, arg1, arg2) +} + +// CFDel mocks base method. +func (m *MockUniversalClient) CFDel(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFDel", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFDel indicates an expected call of CFDel. +func (mr *MockUniversalClientMockRecorder) CFDel(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockUniversalClient)(nil).CFDel), arg0, arg1, arg2) +} + +// CFExists mocks base method. +func (m *MockUniversalClient) CFExists(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFExists", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// CFExists indicates an expected call of CFExists. +func (mr *MockUniversalClientMockRecorder) CFExists(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockUniversalClient)(nil).CFExists), arg0, arg1, arg2) +} + +// CFInfo mocks base method. +func (m *MockUniversalClient) CFInfo(arg0 context.Context, arg1 string) *redis.CFInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.CFInfoCmd) + return ret0 +} + +// CFInfo indicates an expected call of CFInfo. +func (mr *MockUniversalClientMockRecorder) CFInfo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockUniversalClient)(nil).CFInfo), arg0, arg1) +} + +// CFInsert mocks base method. +func (m *MockUniversalClient) CFInsert(arg0 context.Context, arg1 string, arg2 *redis.CFInsertOptions, arg3 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsert", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFInsert indicates an expected call of CFInsert. +func (mr *MockUniversalClientMockRecorder) CFInsert(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockUniversalClient)(nil).CFInsert), varargs...) +} + +// CFInsertNX mocks base method. +func (m *MockUniversalClient) CFInsertNX(arg0 context.Context, arg1 string, arg2 *redis.CFInsertOptions, arg3 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFInsertNX", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CFInsertNX indicates an expected call of CFInsertNX. +func (mr *MockUniversalClientMockRecorder) CFInsertNX(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockUniversalClient)(nil).CFInsertNX), varargs...) +} + +// CFLoadChunk mocks base method. +func (m *MockUniversalClient) CFLoadChunk(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFLoadChunk", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFLoadChunk indicates an expected call of CFLoadChunk. +func (mr *MockUniversalClientMockRecorder) CFLoadChunk(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockUniversalClient)(nil).CFLoadChunk), arg0, arg1, arg2, arg3) +} + +// CFMExists mocks base method. +func (m *MockUniversalClient) CFMExists(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CFMExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// CFMExists indicates an expected call of CFMExists. +func (mr *MockUniversalClientMockRecorder) CFMExists(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockUniversalClient)(nil).CFMExists), varargs...) +} + +// CFReserve mocks base method. +func (m *MockUniversalClient) CFReserve(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserve", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserve indicates an expected call of CFReserve. +func (mr *MockUniversalClientMockRecorder) CFReserve(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockUniversalClient)(nil).CFReserve), arg0, arg1, arg2) +} + +// CFReserveBucketSize mocks base method. +func (m *MockUniversalClient) CFReserveBucketSize(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveBucketSize", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveBucketSize indicates an expected call of CFReserveBucketSize. +func (mr *MockUniversalClientMockRecorder) CFReserveBucketSize(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveBucketSize), arg0, arg1, arg2, arg3) +} + +// CFReserveExpansion mocks base method. +func (m *MockUniversalClient) CFReserveExpansion(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveExpansion", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveExpansion indicates an expected call of CFReserveExpansion. +func (mr *MockUniversalClientMockRecorder) CFReserveExpansion(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveExpansion), arg0, arg1, arg2, arg3) +} + +// CFReserveMaxIterations mocks base method. +func (m *MockUniversalClient) CFReserveMaxIterations(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveMaxIterations", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations. +func (mr *MockUniversalClientMockRecorder) CFReserveMaxIterations(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveMaxIterations), arg0, arg1, arg2, arg3) +} + +// CFReserveWithArgs mocks base method. +func (m *MockUniversalClient) CFReserveWithArgs(arg0 context.Context, arg1 string, arg2 *redis.CFReserveOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFReserveWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CFReserveWithArgs indicates an expected call of CFReserveWithArgs. +func (mr *MockUniversalClientMockRecorder) CFReserveWithArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).CFReserveWithArgs), arg0, arg1, arg2) +} + +// CFScanDump mocks base method. +func (m *MockUniversalClient) CFScanDump(arg0 context.Context, arg1 string, arg2 int64) *redis.ScanDumpCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CFScanDump", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.ScanDumpCmd) + return ret0 +} + +// CFScanDump indicates an expected call of CFScanDump. +func (mr *MockUniversalClientMockRecorder) CFScanDump(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockUniversalClient)(nil).CFScanDump), arg0, arg1, arg2) +} + +// CMSIncrBy mocks base method. +func (m *MockUniversalClient) CMSIncrBy(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSIncrBy", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSIncrBy indicates an expected call of CMSIncrBy. +func (mr *MockUniversalClientMockRecorder) CMSIncrBy(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).CMSIncrBy), varargs...) +} + +// CMSInfo mocks base method. +func (m *MockUniversalClient) CMSInfo(arg0 context.Context, arg1 string) *redis.CMSInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.CMSInfoCmd) + return ret0 +} + +// CMSInfo indicates an expected call of CMSInfo. +func (mr *MockUniversalClientMockRecorder) CMSInfo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockUniversalClient)(nil).CMSInfo), arg0, arg1) +} + +// CMSInitByDim mocks base method. +func (m *MockUniversalClient) CMSInitByDim(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByDim", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByDim indicates an expected call of CMSInitByDim. +func (mr *MockUniversalClientMockRecorder) CMSInitByDim(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockUniversalClient)(nil).CMSInitByDim), arg0, arg1, arg2, arg3) +} + +// CMSInitByProb mocks base method. +func (m *MockUniversalClient) CMSInitByProb(arg0 context.Context, arg1 string, arg2, arg3 float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSInitByProb", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSInitByProb indicates an expected call of CMSInitByProb. +func (mr *MockUniversalClientMockRecorder) CMSInitByProb(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockUniversalClient)(nil).CMSInitByProb), arg0, arg1, arg2, arg3) +} + +// CMSMerge mocks base method. +func (m *MockUniversalClient) CMSMerge(arg0 context.Context, arg1 string, arg2 ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMerge indicates an expected call of CMSMerge. +func (mr *MockUniversalClientMockRecorder) CMSMerge(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockUniversalClient)(nil).CMSMerge), varargs...) +} + +// CMSMergeWithWeight mocks base method. +func (m *MockUniversalClient) CMSMergeWithWeight(arg0 context.Context, arg1 string, arg2 map[string]int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CMSMergeWithWeight", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight. +func (mr *MockUniversalClientMockRecorder) CMSMergeWithWeight(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockUniversalClient)(nil).CMSMergeWithWeight), arg0, arg1, arg2) +} + +// CMSQuery mocks base method. +func (m *MockUniversalClient) CMSQuery(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CMSQuery", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// CMSQuery indicates an expected call of CMSQuery. +func (mr *MockUniversalClientMockRecorder) CMSQuery(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockUniversalClient)(nil).CMSQuery), varargs...) +} + +// ClientGetName mocks base method. +func (m *MockUniversalClient) ClientGetName(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientGetName", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientGetName indicates an expected call of ClientGetName. +func (mr *MockUniversalClientMockRecorder) ClientGetName(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockUniversalClient)(nil).ClientGetName), arg0) +} + +// ClientID mocks base method. +func (m *MockUniversalClient) ClientID(arg0 context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientID", arg0) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientID indicates an expected call of ClientID. +func (mr *MockUniversalClientMockRecorder) ClientID(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockUniversalClient)(nil).ClientID), arg0) +} + +// ClientInfo mocks base method. +func (m *MockUniversalClient) ClientInfo(arg0 context.Context) *redis.ClientInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientInfo", arg0) + ret0, _ := ret[0].(*redis.ClientInfoCmd) + return ret0 +} + +// ClientInfo indicates an expected call of ClientInfo. +func (mr *MockUniversalClientMockRecorder) ClientInfo(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockUniversalClient)(nil).ClientInfo), arg0) +} + +// ClientKill mocks base method. +func (m *MockUniversalClient) ClientKill(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientKill", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClientKill indicates an expected call of ClientKill. +func (mr *MockUniversalClientMockRecorder) ClientKill(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockUniversalClient)(nil).ClientKill), arg0, arg1) +} + +// ClientKillByFilter mocks base method. +func (m *MockUniversalClient) ClientKillByFilter(arg0 context.Context, arg1 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientKillByFilter indicates an expected call of ClientKillByFilter. +func (mr *MockUniversalClientMockRecorder) ClientKillByFilter(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockUniversalClient)(nil).ClientKillByFilter), varargs...) +} + +// ClientList mocks base method. +func (m *MockUniversalClient) ClientList(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientList", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClientList indicates an expected call of ClientList. +func (mr *MockUniversalClientMockRecorder) ClientList(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockUniversalClient)(nil).ClientList), arg0) +} + +// ClientPause mocks base method. +func (m *MockUniversalClient) ClientPause(arg0 context.Context, arg1 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientPause", arg0, arg1) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientPause indicates an expected call of ClientPause. +func (mr *MockUniversalClientMockRecorder) ClientPause(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockUniversalClient)(nil).ClientPause), arg0, arg1) +} + +// ClientUnblock mocks base method. +func (m *MockUniversalClient) ClientUnblock(arg0 context.Context, arg1 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblock", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblock indicates an expected call of ClientUnblock. +func (mr *MockUniversalClientMockRecorder) ClientUnblock(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnblock), arg0, arg1) +} + +// ClientUnblockWithError mocks base method. +func (m *MockUniversalClient) ClientUnblockWithError(arg0 context.Context, arg1 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnblockWithError", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClientUnblockWithError indicates an expected call of ClientUnblockWithError. +func (mr *MockUniversalClientMockRecorder) ClientUnblockWithError(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnblockWithError), arg0, arg1) +} + +// ClientUnpause mocks base method. +func (m *MockUniversalClient) ClientUnpause(arg0 context.Context) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClientUnpause", arg0) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ClientUnpause indicates an expected call of ClientUnpause. +func (mr *MockUniversalClientMockRecorder) ClientUnpause(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockUniversalClient)(nil).ClientUnpause), arg0) +} + +// Close mocks base method. +func (m *MockUniversalClient) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *MockUniversalClientMockRecorder) Close() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockUniversalClient)(nil).Close)) +} + +// ClusterAddSlots mocks base method. +func (m *MockUniversalClient) ClusterAddSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlots indicates an expected call of ClusterAddSlots. +func (mr *MockUniversalClientMockRecorder) ClusterAddSlots(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterAddSlots), varargs...) +} + +// ClusterAddSlotsRange mocks base method. +func (m *MockUniversalClient) ClusterAddSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterAddSlotsRange", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange. +func (mr *MockUniversalClientMockRecorder) ClusterAddSlotsRange(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockUniversalClient)(nil).ClusterAddSlotsRange), arg0, arg1, arg2) +} + +// ClusterCountFailureReports mocks base method. +func (m *MockUniversalClient) ClusterCountFailureReports(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountFailureReports", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports. +func (mr *MockUniversalClientMockRecorder) ClusterCountFailureReports(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockUniversalClient)(nil).ClusterCountFailureReports), arg0, arg1) +} + +// ClusterCountKeysInSlot mocks base method. +func (m *MockUniversalClient) ClusterCountKeysInSlot(arg0 context.Context, arg1 int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot. +func (mr *MockUniversalClientMockRecorder) ClusterCountKeysInSlot(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterCountKeysInSlot), arg0, arg1) +} + +// ClusterDelSlots mocks base method. +func (m *MockUniversalClient) ClusterDelSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlots indicates an expected call of ClusterDelSlots. +func (mr *MockUniversalClientMockRecorder) ClusterDelSlots(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterDelSlots), varargs...) +} + +// ClusterDelSlotsRange mocks base method. +func (m *MockUniversalClient) ClusterDelSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterDelSlotsRange", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange. +func (mr *MockUniversalClientMockRecorder) ClusterDelSlotsRange(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockUniversalClient)(nil).ClusterDelSlotsRange), arg0, arg1, arg2) +} + +// ClusterFailover mocks base method. +func (m *MockUniversalClient) ClusterFailover(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterFailover", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterFailover indicates an expected call of ClusterFailover. +func (mr *MockUniversalClientMockRecorder) ClusterFailover(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockUniversalClient)(nil).ClusterFailover), arg0) +} + +// ClusterForget mocks base method. +func (m *MockUniversalClient) ClusterForget(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterForget", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterForget indicates an expected call of ClusterForget. +func (mr *MockUniversalClientMockRecorder) ClusterForget(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockUniversalClient)(nil).ClusterForget), arg0, arg1) +} + +// ClusterGetKeysInSlot mocks base method. +func (m *MockUniversalClient) ClusterGetKeysInSlot(arg0 context.Context, arg1, arg2 int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot. +func (mr *MockUniversalClientMockRecorder) ClusterGetKeysInSlot(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterGetKeysInSlot), arg0, arg1, arg2) +} + +// ClusterInfo mocks base method. +func (m *MockUniversalClient) ClusterInfo(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterInfo", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterInfo indicates an expected call of ClusterInfo. +func (mr *MockUniversalClientMockRecorder) ClusterInfo(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockUniversalClient)(nil).ClusterInfo), arg0) +} + +// ClusterKeySlot mocks base method. +func (m *MockUniversalClient) ClusterKeySlot(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterKeySlot", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ClusterKeySlot indicates an expected call of ClusterKeySlot. +func (mr *MockUniversalClientMockRecorder) ClusterKeySlot(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockUniversalClient)(nil).ClusterKeySlot), arg0, arg1) +} + +// ClusterLinks mocks base method. +func (m *MockUniversalClient) ClusterLinks(arg0 context.Context) *redis.ClusterLinksCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterLinks", arg0) + ret0, _ := ret[0].(*redis.ClusterLinksCmd) + return ret0 +} + +// ClusterLinks indicates an expected call of ClusterLinks. +func (mr *MockUniversalClientMockRecorder) ClusterLinks(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockUniversalClient)(nil).ClusterLinks), arg0) +} + +// ClusterMeet mocks base method. +func (m *MockUniversalClient) ClusterMeet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMeet", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterMeet indicates an expected call of ClusterMeet. +func (mr *MockUniversalClientMockRecorder) ClusterMeet(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMeet), arg0, arg1, arg2) +} + +// ClusterMyShardID mocks base method. +func (m *MockUniversalClient) ClusterMyShardID(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterMyShardID", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterMyShardID indicates an expected call of ClusterMyShardID. +func (mr *MockUniversalClientMockRecorder) ClusterMyShardID(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockUniversalClient)(nil).ClusterMyShardID), arg0) +} + +// ClusterNodes mocks base method. +func (m *MockUniversalClient) ClusterNodes(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterNodes", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ClusterNodes indicates an expected call of ClusterNodes. +func (mr *MockUniversalClientMockRecorder) ClusterNodes(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockUniversalClient)(nil).ClusterNodes), arg0) +} + +// ClusterReplicate mocks base method. +func (m *MockUniversalClient) ClusterReplicate(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterReplicate", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterReplicate indicates an expected call of ClusterReplicate. +func (mr *MockUniversalClientMockRecorder) ClusterReplicate(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockUniversalClient)(nil).ClusterReplicate), arg0, arg1) +} + +// ClusterResetHard mocks base method. +func (m *MockUniversalClient) ClusterResetHard(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetHard", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetHard indicates an expected call of ClusterResetHard. +func (mr *MockUniversalClientMockRecorder) ClusterResetHard(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockUniversalClient)(nil).ClusterResetHard), arg0) +} + +// ClusterResetSoft mocks base method. +func (m *MockUniversalClient) ClusterResetSoft(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterResetSoft", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterResetSoft indicates an expected call of ClusterResetSoft. +func (mr *MockUniversalClientMockRecorder) ClusterResetSoft(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockUniversalClient)(nil).ClusterResetSoft), arg0) +} + +// ClusterSaveConfig mocks base method. +func (m *MockUniversalClient) ClusterSaveConfig(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSaveConfig", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ClusterSaveConfig indicates an expected call of ClusterSaveConfig. +func (mr *MockUniversalClientMockRecorder) ClusterSaveConfig(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSaveConfig), arg0) +} + +// ClusterShards mocks base method. +func (m *MockUniversalClient) ClusterShards(arg0 context.Context) *redis.ClusterShardsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterShards", arg0) + ret0, _ := ret[0].(*redis.ClusterShardsCmd) + return ret0 +} + +// ClusterShards indicates an expected call of ClusterShards. +func (mr *MockUniversalClientMockRecorder) ClusterShards(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockUniversalClient)(nil).ClusterShards), arg0) +} + +// ClusterSlaves mocks base method. +func (m *MockUniversalClient) ClusterSlaves(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlaves", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ClusterSlaves indicates an expected call of ClusterSlaves. +func (mr *MockUniversalClientMockRecorder) ClusterSlaves(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSlaves), arg0, arg1) +} + +// ClusterSlots mocks base method. +func (m *MockUniversalClient) ClusterSlots(arg0 context.Context) *redis.ClusterSlotsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ClusterSlots", arg0) + ret0, _ := ret[0].(*redis.ClusterSlotsCmd) + return ret0 +} + +// ClusterSlots indicates an expected call of ClusterSlots. +func (mr *MockUniversalClientMockRecorder) ClusterSlots(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockUniversalClient)(nil).ClusterSlots), arg0) +} + +// Command mocks base method. +func (m *MockUniversalClient) Command(arg0 context.Context) *redis.CommandsInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Command", arg0) + ret0, _ := ret[0].(*redis.CommandsInfoCmd) + return ret0 +} + +// Command indicates an expected call of Command. +func (mr *MockUniversalClientMockRecorder) Command(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockUniversalClient)(nil).Command), arg0) +} + +// CommandGetKeys mocks base method. +func (m *MockUniversalClient) CommandGetKeys(arg0 context.Context, arg1 ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeys", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandGetKeys indicates an expected call of CommandGetKeys. +func (mr *MockUniversalClientMockRecorder) CommandGetKeys(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockUniversalClient)(nil).CommandGetKeys), varargs...) +} + +// CommandGetKeysAndFlags mocks base method. +func (m *MockUniversalClient) CommandGetKeysAndFlags(arg0 context.Context, arg1 ...any) *redis.KeyFlagsCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...) + ret0, _ := ret[0].(*redis.KeyFlagsCmd) + return ret0 +} + +// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags. +func (mr *MockUniversalClientMockRecorder) CommandGetKeysAndFlags(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockUniversalClient)(nil).CommandGetKeysAndFlags), varargs...) +} + +// CommandList mocks base method. +func (m *MockUniversalClient) CommandList(arg0 context.Context, arg1 *redis.FilterBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CommandList", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// CommandList indicates an expected call of CommandList. +func (mr *MockUniversalClientMockRecorder) CommandList(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockUniversalClient)(nil).CommandList), arg0, arg1) +} + +// ConfigGet mocks base method. +func (m *MockUniversalClient) ConfigGet(arg0 context.Context, arg1 string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigGet", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// ConfigGet indicates an expected call of ConfigGet. +func (mr *MockUniversalClientMockRecorder) ConfigGet(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockUniversalClient)(nil).ConfigGet), arg0, arg1) +} + +// ConfigResetStat mocks base method. +func (m *MockUniversalClient) ConfigResetStat(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigResetStat", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigResetStat indicates an expected call of ConfigResetStat. +func (mr *MockUniversalClientMockRecorder) ConfigResetStat(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockUniversalClient)(nil).ConfigResetStat), arg0) +} + +// ConfigRewrite mocks base method. +func (m *MockUniversalClient) ConfigRewrite(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigRewrite", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigRewrite indicates an expected call of ConfigRewrite. +func (mr *MockUniversalClientMockRecorder) ConfigRewrite(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockUniversalClient)(nil).ConfigRewrite), arg0) +} + +// ConfigSet mocks base method. +func (m *MockUniversalClient) ConfigSet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConfigSet", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ConfigSet indicates an expected call of ConfigSet. +func (mr *MockUniversalClientMockRecorder) ConfigSet(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockUniversalClient)(nil).ConfigSet), arg0, arg1, arg2) +} + +// Copy mocks base method. +func (m *MockUniversalClient) Copy(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 bool) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Copy", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Copy indicates an expected call of Copy. +func (mr *MockUniversalClientMockRecorder) Copy(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockUniversalClient)(nil).Copy), arg0, arg1, arg2, arg3, arg4) +} + +// DBSize mocks base method. +func (m *MockUniversalClient) DBSize(arg0 context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DBSize", arg0) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DBSize indicates an expected call of DBSize. +func (mr *MockUniversalClientMockRecorder) DBSize(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockUniversalClient)(nil).DBSize), arg0) +} + +// DebugObject mocks base method. +func (m *MockUniversalClient) DebugObject(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DebugObject", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// DebugObject indicates an expected call of DebugObject. +func (mr *MockUniversalClientMockRecorder) DebugObject(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockUniversalClient)(nil).DebugObject), arg0, arg1) +} + +// Decr mocks base method. +func (m *MockUniversalClient) Decr(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Decr", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Decr indicates an expected call of Decr. +func (mr *MockUniversalClientMockRecorder) Decr(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockUniversalClient)(nil).Decr), arg0, arg1) +} + +// DecrBy mocks base method. +func (m *MockUniversalClient) DecrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DecrBy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// DecrBy indicates an expected call of DecrBy. +func (mr *MockUniversalClientMockRecorder) DecrBy(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockUniversalClient)(nil).DecrBy), arg0, arg1, arg2) +} + +// Del mocks base method. +func (m *MockUniversalClient) Del(arg0 context.Context, arg1 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Del", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Del indicates an expected call of Del. +func (mr *MockUniversalClientMockRecorder) Del(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockUniversalClient)(nil).Del), varargs...) +} + +// Do mocks base method. +func (m *MockUniversalClient) Do(arg0 context.Context, arg1 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Do", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Do indicates an expected call of Do. +func (mr *MockUniversalClientMockRecorder) Do(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockUniversalClient)(nil).Do), varargs...) +} + +// Dump mocks base method. +func (m *MockUniversalClient) Dump(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Dump", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Dump indicates an expected call of Dump. +func (mr *MockUniversalClientMockRecorder) Dump(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockUniversalClient)(nil).Dump), arg0, arg1) +} + +// Echo mocks base method. +func (m *MockUniversalClient) Echo(arg0 context.Context, arg1 any) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Echo", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Echo indicates an expected call of Echo. +func (mr *MockUniversalClientMockRecorder) Echo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockUniversalClient)(nil).Echo), arg0, arg1) +} + +// Eval mocks base method. +func (m *MockUniversalClient) Eval(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Eval", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// Eval indicates an expected call of Eval. +func (mr *MockUniversalClientMockRecorder) Eval(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockUniversalClient)(nil).Eval), varargs...) +} + +// EvalRO mocks base method. +func (m *MockUniversalClient) EvalRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalRO indicates an expected call of EvalRO. +func (mr *MockUniversalClientMockRecorder) EvalRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockUniversalClient)(nil).EvalRO), varargs...) +} + +// EvalSha mocks base method. +func (m *MockUniversalClient) EvalSha(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalSha", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalSha indicates an expected call of EvalSha. +func (mr *MockUniversalClientMockRecorder) EvalSha(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockUniversalClient)(nil).EvalSha), varargs...) +} + +// EvalShaRO mocks base method. +func (m *MockUniversalClient) EvalShaRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EvalShaRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// EvalShaRO indicates an expected call of EvalShaRO. +func (mr *MockUniversalClientMockRecorder) EvalShaRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockUniversalClient)(nil).EvalShaRO), varargs...) +} + +// Exists mocks base method. +func (m *MockUniversalClient) Exists(arg0 context.Context, arg1 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Exists", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Exists indicates an expected call of Exists. +func (mr *MockUniversalClientMockRecorder) Exists(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockUniversalClient)(nil).Exists), varargs...) +} + +// Expire mocks base method. +func (m *MockUniversalClient) Expire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Expire", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Expire indicates an expected call of Expire. +func (mr *MockUniversalClientMockRecorder) Expire(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockUniversalClient)(nil).Expire), arg0, arg1, arg2) +} + +// ExpireAt mocks base method. +func (m *MockUniversalClient) ExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireAt", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireAt indicates an expected call of ExpireAt. +func (mr *MockUniversalClientMockRecorder) ExpireAt(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).ExpireAt), arg0, arg1, arg2) +} + +// ExpireGT mocks base method. +func (m *MockUniversalClient) ExpireGT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireGT", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireGT indicates an expected call of ExpireGT. +func (mr *MockUniversalClientMockRecorder) ExpireGT(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockUniversalClient)(nil).ExpireGT), arg0, arg1, arg2) +} + +// ExpireLT mocks base method. +func (m *MockUniversalClient) ExpireLT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireLT", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireLT indicates an expected call of ExpireLT. +func (mr *MockUniversalClientMockRecorder) ExpireLT(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockUniversalClient)(nil).ExpireLT), arg0, arg1, arg2) +} + +// ExpireNX mocks base method. +func (m *MockUniversalClient) ExpireNX(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireNX", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireNX indicates an expected call of ExpireNX. +func (mr *MockUniversalClientMockRecorder) ExpireNX(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockUniversalClient)(nil).ExpireNX), arg0, arg1, arg2) +} + +// ExpireTime mocks base method. +func (m *MockUniversalClient) ExpireTime(arg0 context.Context, arg1 string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireTime", arg0, arg1) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ExpireTime indicates an expected call of ExpireTime. +func (mr *MockUniversalClientMockRecorder) ExpireTime(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).ExpireTime), arg0, arg1) +} + +// ExpireXX mocks base method. +func (m *MockUniversalClient) ExpireXX(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExpireXX", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// ExpireXX indicates an expected call of ExpireXX. +func (mr *MockUniversalClientMockRecorder) ExpireXX(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockUniversalClient)(nil).ExpireXX), arg0, arg1, arg2) +} + +// FCall mocks base method. +func (m *MockUniversalClient) FCall(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCall", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCall indicates an expected call of FCall. +func (mr *MockUniversalClientMockRecorder) FCall(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCall", reflect.TypeOf((*MockUniversalClient)(nil).FCall), varargs...) +} + +// FCallRO mocks base method. +func (m *MockUniversalClient) FCallRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRO", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRO indicates an expected call of FCallRO. +func (mr *MockUniversalClientMockRecorder) FCallRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRO", reflect.TypeOf((*MockUniversalClient)(nil).FCallRO), varargs...) +} + +// FCallRo mocks base method. +func (m *MockUniversalClient) FCallRo(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "FCallRo", varargs...) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// FCallRo indicates an expected call of FCallRo. +func (mr *MockUniversalClientMockRecorder) FCallRo(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FCallRo", reflect.TypeOf((*MockUniversalClient)(nil).FCallRo), varargs...) +} + +// FlushAll mocks base method. +func (m *MockUniversalClient) FlushAll(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAll", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAll indicates an expected call of FlushAll. +func (mr *MockUniversalClientMockRecorder) FlushAll(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockUniversalClient)(nil).FlushAll), arg0) +} + +// FlushAllAsync mocks base method. +func (m *MockUniversalClient) FlushAllAsync(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushAllAsync", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushAllAsync indicates an expected call of FlushAllAsync. +func (mr *MockUniversalClientMockRecorder) FlushAllAsync(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockUniversalClient)(nil).FlushAllAsync), arg0) +} + +// FlushDB mocks base method. +func (m *MockUniversalClient) FlushDB(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDB", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDB indicates an expected call of FlushDB. +func (mr *MockUniversalClientMockRecorder) FlushDB(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockUniversalClient)(nil).FlushDB), arg0) +} + +// FlushDBAsync mocks base method. +func (m *MockUniversalClient) FlushDBAsync(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FlushDBAsync", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// FlushDBAsync indicates an expected call of FlushDBAsync. +func (mr *MockUniversalClientMockRecorder) FlushDBAsync(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockUniversalClient)(nil).FlushDBAsync), arg0) +} + +// FunctionDelete mocks base method. +func (m *MockUniversalClient) FunctionDelete(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDelete", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDelete indicates an expected call of FunctionDelete. +func (mr *MockUniversalClientMockRecorder) FunctionDelete(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockUniversalClient)(nil).FunctionDelete), arg0, arg1) +} + +// FunctionDump mocks base method. +func (m *MockUniversalClient) FunctionDump(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionDump", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionDump indicates an expected call of FunctionDump. +func (mr *MockUniversalClientMockRecorder) FunctionDump(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockUniversalClient)(nil).FunctionDump), arg0) +} + +// FunctionFlush mocks base method. +func (m *MockUniversalClient) FunctionFlush(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlush", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlush indicates an expected call of FunctionFlush. +func (mr *MockUniversalClientMockRecorder) FunctionFlush(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockUniversalClient)(nil).FunctionFlush), arg0) +} + +// FunctionFlushAsync mocks base method. +func (m *MockUniversalClient) FunctionFlushAsync(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionFlushAsync", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionFlushAsync indicates an expected call of FunctionFlushAsync. +func (mr *MockUniversalClientMockRecorder) FunctionFlushAsync(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockUniversalClient)(nil).FunctionFlushAsync), arg0) +} + +// FunctionKill mocks base method. +func (m *MockUniversalClient) FunctionKill(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionKill", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionKill indicates an expected call of FunctionKill. +func (mr *MockUniversalClientMockRecorder) FunctionKill(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockUniversalClient)(nil).FunctionKill), arg0) +} + +// FunctionList mocks base method. +func (m *MockUniversalClient) FunctionList(arg0 context.Context, arg1 redis.FunctionListQuery) *redis.FunctionListCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionList", arg0, arg1) + ret0, _ := ret[0].(*redis.FunctionListCmd) + return ret0 +} + +// FunctionList indicates an expected call of FunctionList. +func (mr *MockUniversalClientMockRecorder) FunctionList(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockUniversalClient)(nil).FunctionList), arg0, arg1) +} + +// FunctionLoad mocks base method. +func (m *MockUniversalClient) FunctionLoad(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoad", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoad indicates an expected call of FunctionLoad. +func (mr *MockUniversalClientMockRecorder) FunctionLoad(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockUniversalClient)(nil).FunctionLoad), arg0, arg1) +} + +// FunctionLoadReplace mocks base method. +func (m *MockUniversalClient) FunctionLoadReplace(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionLoadReplace", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionLoadReplace indicates an expected call of FunctionLoadReplace. +func (mr *MockUniversalClientMockRecorder) FunctionLoadReplace(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockUniversalClient)(nil).FunctionLoadReplace), arg0, arg1) +} + +// FunctionRestore mocks base method. +func (m *MockUniversalClient) FunctionRestore(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionRestore", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// FunctionRestore indicates an expected call of FunctionRestore. +func (mr *MockUniversalClientMockRecorder) FunctionRestore(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockUniversalClient)(nil).FunctionRestore), arg0, arg1) +} + +// FunctionStats mocks base method. +func (m *MockUniversalClient) FunctionStats(arg0 context.Context) *redis.FunctionStatsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FunctionStats", arg0) + ret0, _ := ret[0].(*redis.FunctionStatsCmd) + return ret0 +} + +// FunctionStats indicates an expected call of FunctionStats. +func (mr *MockUniversalClientMockRecorder) FunctionStats(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockUniversalClient)(nil).FunctionStats), arg0) +} + +// GeoAdd mocks base method. +func (m *MockUniversalClient) GeoAdd(arg0 context.Context, arg1 string, arg2 ...*redis.GeoLocation) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoAdd indicates an expected call of GeoAdd. +func (mr *MockUniversalClientMockRecorder) GeoAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockUniversalClient)(nil).GeoAdd), varargs...) +} + +// GeoDist mocks base method. +func (m *MockUniversalClient) GeoDist(arg0 context.Context, arg1, arg2, arg3, arg4 string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoDist", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// GeoDist indicates an expected call of GeoDist. +func (mr *MockUniversalClientMockRecorder) GeoDist(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockUniversalClient)(nil).GeoDist), arg0, arg1, arg2, arg3, arg4) +} + +// GeoHash mocks base method. +func (m *MockUniversalClient) GeoHash(arg0 context.Context, arg1 string, arg2 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoHash", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoHash indicates an expected call of GeoHash. +func (mr *MockUniversalClientMockRecorder) GeoHash(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockUniversalClient)(nil).GeoHash), varargs...) +} + +// GeoPos mocks base method. +func (m *MockUniversalClient) GeoPos(arg0 context.Context, arg1 string, arg2 ...string) *redis.GeoPosCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GeoPos", varargs...) + ret0, _ := ret[0].(*redis.GeoPosCmd) + return ret0 +} + +// GeoPos indicates an expected call of GeoPos. +func (mr *MockUniversalClientMockRecorder) GeoPos(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockUniversalClient)(nil).GeoPos), varargs...) +} + +// GeoRadius mocks base method. +func (m *MockUniversalClient) GeoRadius(arg0 context.Context, arg1 string, arg2, arg3 float64, arg4 *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadius", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadius indicates an expected call of GeoRadius. +func (mr *MockUniversalClientMockRecorder) GeoRadius(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadius), arg0, arg1, arg2, arg3, arg4) +} + +// GeoRadiusByMember mocks base method. +func (m *MockUniversalClient) GeoRadiusByMember(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoRadiusQuery) *redis.GeoLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMember", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.GeoLocationCmd) + return ret0 +} + +// GeoRadiusByMember indicates an expected call of GeoRadiusByMember. +func (mr *MockUniversalClientMockRecorder) GeoRadiusByMember(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusByMember), arg0, arg1, arg2, arg3) +} + +// GeoRadiusByMemberStore mocks base method. +func (m *MockUniversalClient) GeoRadiusByMemberStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore. +func (mr *MockUniversalClientMockRecorder) GeoRadiusByMemberStore(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusByMemberStore), arg0, arg1, arg2, arg3) +} + +// GeoRadiusStore mocks base method. +func (m *MockUniversalClient) GeoRadiusStore(arg0 context.Context, arg1 string, arg2, arg3 float64, arg4 *redis.GeoRadiusQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoRadiusStore", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoRadiusStore indicates an expected call of GeoRadiusStore. +func (mr *MockUniversalClientMockRecorder) GeoRadiusStore(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoRadiusStore), arg0, arg1, arg2, arg3, arg4) +} + +// GeoSearch mocks base method. +func (m *MockUniversalClient) GeoSearch(arg0 context.Context, arg1 string, arg2 *redis.GeoSearchQuery) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearch", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// GeoSearch indicates an expected call of GeoSearch. +func (mr *MockUniversalClientMockRecorder) GeoSearch(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearch), arg0, arg1, arg2) +} + +// GeoSearchLocation mocks base method. +func (m *MockUniversalClient) GeoSearchLocation(arg0 context.Context, arg1 string, arg2 *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchLocation", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.GeoSearchLocationCmd) + return ret0 +} + +// GeoSearchLocation indicates an expected call of GeoSearchLocation. +func (mr *MockUniversalClientMockRecorder) GeoSearchLocation(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearchLocation), arg0, arg1, arg2) +} + +// GeoSearchStore mocks base method. +func (m *MockUniversalClient) GeoSearchStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoSearchStoreQuery) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GeoSearchStore", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GeoSearchStore indicates an expected call of GeoSearchStore. +func (mr *MockUniversalClientMockRecorder) GeoSearchStore(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockUniversalClient)(nil).GeoSearchStore), arg0, arg1, arg2, arg3) +} + +// Get mocks base method. +func (m *MockUniversalClient) Get(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Get indicates an expected call of Get. +func (mr *MockUniversalClientMockRecorder) Get(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockUniversalClient)(nil).Get), arg0, arg1) +} + +// GetBit mocks base method. +func (m *MockUniversalClient) GetBit(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetBit", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// GetBit indicates an expected call of GetBit. +func (mr *MockUniversalClientMockRecorder) GetBit(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockUniversalClient)(nil).GetBit), arg0, arg1, arg2) +} + +// GetDel mocks base method. +func (m *MockUniversalClient) GetDel(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDel", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetDel indicates an expected call of GetDel. +func (mr *MockUniversalClientMockRecorder) GetDel(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockUniversalClient)(nil).GetDel), arg0, arg1) +} + +// GetEx mocks base method. +func (m *MockUniversalClient) GetEx(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetEx", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetEx indicates an expected call of GetEx. +func (mr *MockUniversalClientMockRecorder) GetEx(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockUniversalClient)(nil).GetEx), arg0, arg1, arg2) +} + +// GetRange mocks base method. +func (m *MockUniversalClient) GetRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetRange indicates an expected call of GetRange. +func (mr *MockUniversalClientMockRecorder) GetRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockUniversalClient)(nil).GetRange), arg0, arg1, arg2, arg3) +} + +// GetSet mocks base method. +func (m *MockUniversalClient) GetSet(arg0 context.Context, arg1 string, arg2 any) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetSet", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// GetSet indicates an expected call of GetSet. +func (mr *MockUniversalClientMockRecorder) GetSet(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockUniversalClient)(nil).GetSet), arg0, arg1, arg2) +} + +// HDel mocks base method. +func (m *MockUniversalClient) HDel(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HDel indicates an expected call of HDel. +func (mr *MockUniversalClientMockRecorder) HDel(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockUniversalClient)(nil).HDel), varargs...) +} + +// HExists mocks base method. +func (m *MockUniversalClient) HExists(arg0 context.Context, arg1, arg2 string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HExists", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HExists indicates an expected call of HExists. +func (mr *MockUniversalClientMockRecorder) HExists(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockUniversalClient)(nil).HExists), arg0, arg1, arg2) +} + +// HGet mocks base method. +func (m *MockUniversalClient) HGet(arg0 context.Context, arg1, arg2 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGet", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// HGet indicates an expected call of HGet. +func (mr *MockUniversalClientMockRecorder) HGet(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockUniversalClient)(nil).HGet), arg0, arg1, arg2) +} + +// HGetAll mocks base method. +func (m *MockUniversalClient) HGetAll(arg0 context.Context, arg1 string) *redis.MapStringStringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HGetAll", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringStringCmd) + return ret0 +} + +// HGetAll indicates an expected call of HGetAll. +func (mr *MockUniversalClientMockRecorder) HGetAll(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockUniversalClient)(nil).HGetAll), arg0, arg1) +} + +// HIncrBy mocks base method. +func (m *MockUniversalClient) HIncrBy(arg0 context.Context, arg1, arg2 string, arg3 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrBy", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HIncrBy indicates an expected call of HIncrBy. +func (mr *MockUniversalClientMockRecorder) HIncrBy(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).HIncrBy), arg0, arg1, arg2, arg3) +} + +// HIncrByFloat mocks base method. +func (m *MockUniversalClient) HIncrByFloat(arg0 context.Context, arg1, arg2 string, arg3 float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HIncrByFloat", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// HIncrByFloat indicates an expected call of HIncrByFloat. +func (mr *MockUniversalClientMockRecorder) HIncrByFloat(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockUniversalClient)(nil).HIncrByFloat), arg0, arg1, arg2, arg3) +} + +// HKeys mocks base method. +func (m *MockUniversalClient) HKeys(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HKeys", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HKeys indicates an expected call of HKeys. +func (mr *MockUniversalClientMockRecorder) HKeys(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockUniversalClient)(nil).HKeys), arg0, arg1) +} + +// HLen mocks base method. +func (m *MockUniversalClient) HLen(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HLen", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HLen indicates an expected call of HLen. +func (mr *MockUniversalClientMockRecorder) HLen(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockUniversalClient)(nil).HLen), arg0, arg1) +} + +// HMGet mocks base method. +func (m *MockUniversalClient) HMGet(arg0 context.Context, arg1 string, arg2 ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// HMGet indicates an expected call of HMGet. +func (mr *MockUniversalClientMockRecorder) HMGet(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockUniversalClient)(nil).HMGet), varargs...) +} + +// HMSet mocks base method. +func (m *MockUniversalClient) HMSet(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HMSet", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HMSet indicates an expected call of HMSet. +func (mr *MockUniversalClientMockRecorder) HMSet(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockUniversalClient)(nil).HMSet), varargs...) +} + +// HRandField mocks base method. +func (m *MockUniversalClient) HRandField(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandField", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HRandField indicates an expected call of HRandField. +func (mr *MockUniversalClientMockRecorder) HRandField(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockUniversalClient)(nil).HRandField), arg0, arg1, arg2) +} + +// HRandFieldWithValues mocks base method. +func (m *MockUniversalClient) HRandFieldWithValues(arg0 context.Context, arg1 string, arg2 int) *redis.KeyValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HRandFieldWithValues", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.KeyValueSliceCmd) + return ret0 +} + +// HRandFieldWithValues indicates an expected call of HRandFieldWithValues. +func (mr *MockUniversalClientMockRecorder) HRandFieldWithValues(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockUniversalClient)(nil).HRandFieldWithValues), arg0, arg1, arg2) +} + +// HScan mocks base method. +func (m *MockUniversalClient) HScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HScan", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// HScan indicates an expected call of HScan. +func (mr *MockUniversalClientMockRecorder) HScan(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockUniversalClient)(nil).HScan), arg0, arg1, arg2, arg3, arg4) +} + +// HSet mocks base method. +func (m *MockUniversalClient) HSet(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "HSet", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// HSet indicates an expected call of HSet. +func (mr *MockUniversalClientMockRecorder) HSet(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockUniversalClient)(nil).HSet), varargs...) +} + +// HSetNX mocks base method. +func (m *MockUniversalClient) HSetNX(arg0 context.Context, arg1, arg2 string, arg3 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HSetNX", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// HSetNX indicates an expected call of HSetNX. +func (mr *MockUniversalClientMockRecorder) HSetNX(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockUniversalClient)(nil).HSetNX), arg0, arg1, arg2, arg3) +} + +// HVals mocks base method. +func (m *MockUniversalClient) HVals(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "HVals", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// HVals indicates an expected call of HVals. +func (mr *MockUniversalClientMockRecorder) HVals(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockUniversalClient)(nil).HVals), arg0, arg1) +} + +// Incr mocks base method. +func (m *MockUniversalClient) Incr(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Incr", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Incr indicates an expected call of Incr. +func (mr *MockUniversalClientMockRecorder) Incr(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockUniversalClient)(nil).Incr), arg0, arg1) +} + +// IncrBy mocks base method. +func (m *MockUniversalClient) IncrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrBy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// IncrBy indicates an expected call of IncrBy. +func (mr *MockUniversalClientMockRecorder) IncrBy(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockUniversalClient)(nil).IncrBy), arg0, arg1, arg2) +} + +// IncrByFloat mocks base method. +func (m *MockUniversalClient) IncrByFloat(arg0 context.Context, arg1 string, arg2 float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IncrByFloat", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// IncrByFloat indicates an expected call of IncrByFloat. +func (mr *MockUniversalClientMockRecorder) IncrByFloat(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockUniversalClient)(nil).IncrByFloat), arg0, arg1, arg2) +} + +// Info mocks base method. +func (m *MockUniversalClient) Info(arg0 context.Context, arg1 ...string) *redis.StringCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Info", varargs...) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// Info indicates an expected call of Info. +func (mr *MockUniversalClientMockRecorder) Info(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockUniversalClient)(nil).Info), varargs...) +} + +// JSONArrAppend mocks base method. +func (m *MockUniversalClient) JSONArrAppend(arg0 context.Context, arg1, arg2 string, arg3 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrAppend", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrAppend indicates an expected call of JSONArrAppend. +func (mr *MockUniversalClientMockRecorder) JSONArrAppend(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrAppend", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrAppend), varargs...) +} + +// JSONArrIndex mocks base method. +func (m *MockUniversalClient) JSONArrIndex(arg0 context.Context, arg1, arg2 string, arg3 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrIndex", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrIndex indicates an expected call of JSONArrIndex. +func (mr *MockUniversalClientMockRecorder) JSONArrIndex(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndex", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrIndex), varargs...) +} + +// JSONArrIndexWithArgs mocks base method. +func (m *MockUniversalClient) JSONArrIndexWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.JSONArrIndexArgs, arg4 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2, arg3} + for _, a := range arg4 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrIndexWithArgs", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrIndexWithArgs indicates an expected call of JSONArrIndexWithArgs. +func (mr *MockUniversalClientMockRecorder) JSONArrIndexWithArgs(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrIndexWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrIndexWithArgs), varargs...) +} + +// JSONArrInsert mocks base method. +func (m *MockUniversalClient) JSONArrInsert(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2, arg3} + for _, a := range arg4 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONArrInsert", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrInsert indicates an expected call of JSONArrInsert. +func (mr *MockUniversalClientMockRecorder) JSONArrInsert(arg0, arg1, arg2, arg3 any, arg4 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2, arg3}, arg4...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrInsert", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrInsert), varargs...) +} + +// JSONArrLen mocks base method. +func (m *MockUniversalClient) JSONArrLen(arg0 context.Context, arg1, arg2 string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrLen", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrLen indicates an expected call of JSONArrLen. +func (mr *MockUniversalClientMockRecorder) JSONArrLen(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrLen), arg0, arg1, arg2) +} + +// JSONArrPop mocks base method. +func (m *MockUniversalClient) JSONArrPop(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrPop", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// JSONArrPop indicates an expected call of JSONArrPop. +func (mr *MockUniversalClientMockRecorder) JSONArrPop(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrPop", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrPop), arg0, arg1, arg2, arg3) +} + +// JSONArrTrim mocks base method. +func (m *MockUniversalClient) JSONArrTrim(arg0 context.Context, arg1, arg2 string) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrTrim", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrTrim indicates an expected call of JSONArrTrim. +func (mr *MockUniversalClientMockRecorder) JSONArrTrim(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrim", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrTrim), arg0, arg1, arg2) +} + +// JSONArrTrimWithArgs mocks base method. +func (m *MockUniversalClient) JSONArrTrimWithArgs(arg0 context.Context, arg1, arg2 string, arg3 *redis.JSONArrTrimArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONArrTrimWithArgs", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// JSONArrTrimWithArgs indicates an expected call of JSONArrTrimWithArgs. +func (mr *MockUniversalClientMockRecorder) JSONArrTrimWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrimWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONArrTrimWithArgs), arg0, arg1, arg2, arg3) +} + +// JSONClear mocks base method. +func (m *MockUniversalClient) JSONClear(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONClear", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONClear indicates an expected call of JSONClear. +func (mr *MockUniversalClientMockRecorder) JSONClear(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONClear", reflect.TypeOf((*MockUniversalClient)(nil).JSONClear), arg0, arg1, arg2) +} + +// JSONDebugMemory mocks base method. +func (m *MockUniversalClient) JSONDebugMemory(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONDebugMemory", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONDebugMemory indicates an expected call of JSONDebugMemory. +func (mr *MockUniversalClientMockRecorder) JSONDebugMemory(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDebugMemory", reflect.TypeOf((*MockUniversalClient)(nil).JSONDebugMemory), arg0, arg1, arg2) +} + +// JSONDel mocks base method. +func (m *MockUniversalClient) JSONDel(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONDel", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONDel indicates an expected call of JSONDel. +func (mr *MockUniversalClientMockRecorder) JSONDel(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDel", reflect.TypeOf((*MockUniversalClient)(nil).JSONDel), arg0, arg1, arg2) +} + +// JSONForget mocks base method. +func (m *MockUniversalClient) JSONForget(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONForget", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// JSONForget indicates an expected call of JSONForget. +func (mr *MockUniversalClientMockRecorder) JSONForget(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONForget", reflect.TypeOf((*MockUniversalClient)(nil).JSONForget), arg0, arg1, arg2) +} + +// JSONGet mocks base method. +func (m *MockUniversalClient) JSONGet(arg0 context.Context, arg1 string, arg2 ...string) *redis.JSONCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONGet", varargs...) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONGet indicates an expected call of JSONGet. +func (mr *MockUniversalClientMockRecorder) JSONGet(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGet", reflect.TypeOf((*MockUniversalClient)(nil).JSONGet), varargs...) +} + +// JSONGetWithArgs mocks base method. +func (m *MockUniversalClient) JSONGetWithArgs(arg0 context.Context, arg1 string, arg2 *redis.JSONGetArgs, arg3 ...string) *redis.JSONCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONGetWithArgs", varargs...) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONGetWithArgs indicates an expected call of JSONGetWithArgs. +func (mr *MockUniversalClientMockRecorder) JSONGetWithArgs(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONGetWithArgs), varargs...) +} + +// JSONMGet mocks base method. +func (m *MockUniversalClient) JSONMGet(arg0 context.Context, arg1 string, arg2 ...string) *redis.JSONSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONMGet", varargs...) + ret0, _ := ret[0].(*redis.JSONSliceCmd) + return ret0 +} + +// JSONMGet indicates an expected call of JSONMGet. +func (mr *MockUniversalClientMockRecorder) JSONMGet(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMGet", reflect.TypeOf((*MockUniversalClient)(nil).JSONMGet), varargs...) +} + +// JSONMSet mocks base method. +func (m *MockUniversalClient) JSONMSet(arg0 context.Context, arg1 ...any) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "JSONMSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMSet indicates an expected call of JSONMSet. +func (mr *MockUniversalClientMockRecorder) JSONMSet(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSet", reflect.TypeOf((*MockUniversalClient)(nil).JSONMSet), varargs...) +} + +// JSONMSetArgs mocks base method. +func (m *MockUniversalClient) JSONMSetArgs(arg0 context.Context, arg1 []redis.JSONSetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONMSetArgs", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMSetArgs indicates an expected call of JSONMSetArgs. +func (mr *MockUniversalClientMockRecorder) JSONMSetArgs(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSetArgs", reflect.TypeOf((*MockUniversalClient)(nil).JSONMSetArgs), arg0, arg1) +} + +// JSONMerge mocks base method. +func (m *MockUniversalClient) JSONMerge(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONMerge", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONMerge indicates an expected call of JSONMerge. +func (mr *MockUniversalClientMockRecorder) JSONMerge(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMerge", reflect.TypeOf((*MockUniversalClient)(nil).JSONMerge), arg0, arg1, arg2, arg3) +} + +// JSONNumIncrBy mocks base method. +func (m *MockUniversalClient) JSONNumIncrBy(arg0 context.Context, arg1, arg2 string, arg3 float64) *redis.JSONCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONNumIncrBy", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.JSONCmd) + return ret0 +} + +// JSONNumIncrBy indicates an expected call of JSONNumIncrBy. +func (mr *MockUniversalClientMockRecorder) JSONNumIncrBy(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONNumIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).JSONNumIncrBy), arg0, arg1, arg2, arg3) +} + +// JSONObjKeys mocks base method. +func (m *MockUniversalClient) JSONObjKeys(arg0 context.Context, arg1, arg2 string) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONObjKeys", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// JSONObjKeys indicates an expected call of JSONObjKeys. +func (mr *MockUniversalClientMockRecorder) JSONObjKeys(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjKeys", reflect.TypeOf((*MockUniversalClient)(nil).JSONObjKeys), arg0, arg1, arg2) +} + +// JSONObjLen mocks base method. +func (m *MockUniversalClient) JSONObjLen(arg0 context.Context, arg1, arg2 string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONObjLen", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONObjLen indicates an expected call of JSONObjLen. +func (mr *MockUniversalClientMockRecorder) JSONObjLen(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONObjLen), arg0, arg1, arg2) +} + +// JSONSet mocks base method. +func (m *MockUniversalClient) JSONSet(arg0 context.Context, arg1, arg2 string, arg3 any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONSet", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONSet indicates an expected call of JSONSet. +func (mr *MockUniversalClientMockRecorder) JSONSet(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSet", reflect.TypeOf((*MockUniversalClient)(nil).JSONSet), arg0, arg1, arg2, arg3) +} + +// JSONSetMode mocks base method. +func (m *MockUniversalClient) JSONSetMode(arg0 context.Context, arg1, arg2 string, arg3 any, arg4 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONSetMode", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// JSONSetMode indicates an expected call of JSONSetMode. +func (mr *MockUniversalClientMockRecorder) JSONSetMode(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSetMode", reflect.TypeOf((*MockUniversalClient)(nil).JSONSetMode), arg0, arg1, arg2, arg3, arg4) +} + +// JSONStrAppend mocks base method. +func (m *MockUniversalClient) JSONStrAppend(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONStrAppend", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONStrAppend indicates an expected call of JSONStrAppend. +func (mr *MockUniversalClientMockRecorder) JSONStrAppend(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrAppend", reflect.TypeOf((*MockUniversalClient)(nil).JSONStrAppend), arg0, arg1, arg2, arg3) +} + +// JSONStrLen mocks base method. +func (m *MockUniversalClient) JSONStrLen(arg0 context.Context, arg1, arg2 string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONStrLen", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONStrLen indicates an expected call of JSONStrLen. +func (mr *MockUniversalClientMockRecorder) JSONStrLen(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrLen", reflect.TypeOf((*MockUniversalClient)(nil).JSONStrLen), arg0, arg1, arg2) +} + +// JSONToggle mocks base method. +func (m *MockUniversalClient) JSONToggle(arg0 context.Context, arg1, arg2 string) *redis.IntPointerSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONToggle", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntPointerSliceCmd) + return ret0 +} + +// JSONToggle indicates an expected call of JSONToggle. +func (mr *MockUniversalClientMockRecorder) JSONToggle(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONToggle", reflect.TypeOf((*MockUniversalClient)(nil).JSONToggle), arg0, arg1, arg2) +} + +// JSONType mocks base method. +func (m *MockUniversalClient) JSONType(arg0 context.Context, arg1, arg2 string) *redis.JSONSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "JSONType", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.JSONSliceCmd) + return ret0 +} + +// JSONType indicates an expected call of JSONType. +func (mr *MockUniversalClientMockRecorder) JSONType(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONType", reflect.TypeOf((*MockUniversalClient)(nil).JSONType), arg0, arg1, arg2) +} + +// Keys mocks base method. +func (m *MockUniversalClient) Keys(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Keys", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Keys indicates an expected call of Keys. +func (mr *MockUniversalClientMockRecorder) Keys(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockUniversalClient)(nil).Keys), arg0, arg1) +} + +// LCS mocks base method. +func (m *MockUniversalClient) LCS(arg0 context.Context, arg1 *redis.LCSQuery) *redis.LCSCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LCS", arg0, arg1) + ret0, _ := ret[0].(*redis.LCSCmd) + return ret0 +} + +// LCS indicates an expected call of LCS. +func (mr *MockUniversalClientMockRecorder) LCS(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockUniversalClient)(nil).LCS), arg0, arg1) +} + +// LIndex mocks base method. +func (m *MockUniversalClient) LIndex(arg0 context.Context, arg1 string, arg2 int64) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LIndex", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LIndex indicates an expected call of LIndex. +func (mr *MockUniversalClientMockRecorder) LIndex(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockUniversalClient)(nil).LIndex), arg0, arg1, arg2) +} + +// LInsert mocks base method. +func (m *MockUniversalClient) LInsert(arg0 context.Context, arg1, arg2 string, arg3, arg4 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsert", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsert indicates an expected call of LInsert. +func (mr *MockUniversalClientMockRecorder) LInsert(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockUniversalClient)(nil).LInsert), arg0, arg1, arg2, arg3, arg4) +} + +// LInsertAfter mocks base method. +func (m *MockUniversalClient) LInsertAfter(arg0 context.Context, arg1 string, arg2, arg3 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertAfter", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertAfter indicates an expected call of LInsertAfter. +func (mr *MockUniversalClientMockRecorder) LInsertAfter(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockUniversalClient)(nil).LInsertAfter), arg0, arg1, arg2, arg3) +} + +// LInsertBefore mocks base method. +func (m *MockUniversalClient) LInsertBefore(arg0 context.Context, arg1 string, arg2, arg3 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LInsertBefore", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LInsertBefore indicates an expected call of LInsertBefore. +func (mr *MockUniversalClientMockRecorder) LInsertBefore(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockUniversalClient)(nil).LInsertBefore), arg0, arg1, arg2, arg3) +} + +// LLen mocks base method. +func (m *MockUniversalClient) LLen(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LLen", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LLen indicates an expected call of LLen. +func (mr *MockUniversalClientMockRecorder) LLen(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockUniversalClient)(nil).LLen), arg0, arg1) +} + +// LMPop mocks base method. +func (m *MockUniversalClient) LMPop(arg0 context.Context, arg1 string, arg2 int64, arg3 ...string) *redis.KeyValuesCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LMPop", varargs...) + ret0, _ := ret[0].(*redis.KeyValuesCmd) + return ret0 +} + +// LMPop indicates an expected call of LMPop. +func (mr *MockUniversalClientMockRecorder) LMPop(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMPop", reflect.TypeOf((*MockUniversalClient)(nil).LMPop), varargs...) +} + +// LMove mocks base method. +func (m *MockUniversalClient) LMove(arg0 context.Context, arg1, arg2, arg3, arg4 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LMove", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LMove indicates an expected call of LMove. +func (mr *MockUniversalClientMockRecorder) LMove(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockUniversalClient)(nil).LMove), arg0, arg1, arg2, arg3, arg4) +} + +// LPop mocks base method. +func (m *MockUniversalClient) LPop(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPop", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// LPop indicates an expected call of LPop. +func (mr *MockUniversalClientMockRecorder) LPop(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockUniversalClient)(nil).LPop), arg0, arg1) +} + +// LPopCount mocks base method. +func (m *MockUniversalClient) LPopCount(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPopCount", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LPopCount indicates an expected call of LPopCount. +func (mr *MockUniversalClientMockRecorder) LPopCount(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockUniversalClient)(nil).LPopCount), arg0, arg1, arg2) +} + +// LPos mocks base method. +func (m *MockUniversalClient) LPos(arg0 context.Context, arg1, arg2 string, arg3 redis.LPosArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPos", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPos indicates an expected call of LPos. +func (mr *MockUniversalClientMockRecorder) LPos(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockUniversalClient)(nil).LPos), arg0, arg1, arg2, arg3) +} + +// LPosCount mocks base method. +func (m *MockUniversalClient) LPosCount(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 redis.LPosArgs) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LPosCount", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// LPosCount indicates an expected call of LPosCount. +func (mr *MockUniversalClientMockRecorder) LPosCount(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockUniversalClient)(nil).LPosCount), arg0, arg1, arg2, arg3, arg4) +} + +// LPush mocks base method. +func (m *MockUniversalClient) LPush(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPush indicates an expected call of LPush. +func (mr *MockUniversalClientMockRecorder) LPush(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockUniversalClient)(nil).LPush), varargs...) +} + +// LPushX mocks base method. +func (m *MockUniversalClient) LPushX(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "LPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LPushX indicates an expected call of LPushX. +func (mr *MockUniversalClientMockRecorder) LPushX(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockUniversalClient)(nil).LPushX), varargs...) +} + +// LRange mocks base method. +func (m *MockUniversalClient) LRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// LRange indicates an expected call of LRange. +func (mr *MockUniversalClientMockRecorder) LRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockUniversalClient)(nil).LRange), arg0, arg1, arg2, arg3) +} + +// LRem mocks base method. +func (m *MockUniversalClient) LRem(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LRem", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LRem indicates an expected call of LRem. +func (mr *MockUniversalClientMockRecorder) LRem(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockUniversalClient)(nil).LRem), arg0, arg1, arg2, arg3) +} + +// LSet mocks base method. +func (m *MockUniversalClient) LSet(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LSet", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LSet indicates an expected call of LSet. +func (mr *MockUniversalClientMockRecorder) LSet(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockUniversalClient)(nil).LSet), arg0, arg1, arg2, arg3) +} + +// LTrim mocks base method. +func (m *MockUniversalClient) LTrim(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LTrim", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// LTrim indicates an expected call of LTrim. +func (mr *MockUniversalClientMockRecorder) LTrim(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockUniversalClient)(nil).LTrim), arg0, arg1, arg2, arg3) +} + +// LastSave mocks base method. +func (m *MockUniversalClient) LastSave(arg0 context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "LastSave", arg0) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// LastSave indicates an expected call of LastSave. +func (mr *MockUniversalClientMockRecorder) LastSave(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockUniversalClient)(nil).LastSave), arg0) +} + +// MGet mocks base method. +func (m *MockUniversalClient) MGet(arg0 context.Context, arg1 ...string) *redis.SliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MGet", varargs...) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// MGet indicates an expected call of MGet. +func (mr *MockUniversalClientMockRecorder) MGet(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockUniversalClient)(nil).MGet), varargs...) +} + +// MSet mocks base method. +func (m *MockUniversalClient) MSet(arg0 context.Context, arg1 ...any) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSet", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// MSet indicates an expected call of MSet. +func (mr *MockUniversalClientMockRecorder) MSet(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockUniversalClient)(nil).MSet), varargs...) +} + +// MSetNX mocks base method. +func (m *MockUniversalClient) MSetNX(arg0 context.Context, arg1 ...any) *redis.BoolCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MSetNX", varargs...) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// MSetNX indicates an expected call of MSetNX. +func (mr *MockUniversalClientMockRecorder) MSetNX(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockUniversalClient)(nil).MSetNX), varargs...) +} + +// MemoryUsage mocks base method. +func (m *MockUniversalClient) MemoryUsage(arg0 context.Context, arg1 string, arg2 ...int) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "MemoryUsage", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// MemoryUsage indicates an expected call of MemoryUsage. +func (mr *MockUniversalClientMockRecorder) MemoryUsage(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockUniversalClient)(nil).MemoryUsage), varargs...) +} + +// Migrate mocks base method. +func (m *MockUniversalClient) Migrate(arg0 context.Context, arg1, arg2, arg3 string, arg4 int, arg5 time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Migrate", arg0, arg1, arg2, arg3, arg4, arg5) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Migrate indicates an expected call of Migrate. +func (mr *MockUniversalClientMockRecorder) Migrate(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockUniversalClient)(nil).Migrate), arg0, arg1, arg2, arg3, arg4, arg5) +} + +// ModuleLoadex mocks base method. +func (m *MockUniversalClient) ModuleLoadex(arg0 context.Context, arg1 *redis.ModuleLoadexConfig) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ModuleLoadex", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ModuleLoadex indicates an expected call of ModuleLoadex. +func (mr *MockUniversalClientMockRecorder) ModuleLoadex(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockUniversalClient)(nil).ModuleLoadex), arg0, arg1) +} + +// Move mocks base method. +func (m *MockUniversalClient) Move(arg0 context.Context, arg1 string, arg2 int) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Move", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Move indicates an expected call of Move. +func (mr *MockUniversalClientMockRecorder) Move(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockUniversalClient)(nil).Move), arg0, arg1, arg2) +} + +// ObjectEncoding mocks base method. +func (m *MockUniversalClient) ObjectEncoding(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectEncoding", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ObjectEncoding indicates an expected call of ObjectEncoding. +func (mr *MockUniversalClientMockRecorder) ObjectEncoding(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockUniversalClient)(nil).ObjectEncoding), arg0, arg1) +} + +// ObjectIdleTime mocks base method. +func (m *MockUniversalClient) ObjectIdleTime(arg0 context.Context, arg1 string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectIdleTime", arg0, arg1) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// ObjectIdleTime indicates an expected call of ObjectIdleTime. +func (mr *MockUniversalClientMockRecorder) ObjectIdleTime(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockUniversalClient)(nil).ObjectIdleTime), arg0, arg1) +} + +// ObjectRefCount mocks base method. +func (m *MockUniversalClient) ObjectRefCount(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ObjectRefCount", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ObjectRefCount indicates an expected call of ObjectRefCount. +func (mr *MockUniversalClientMockRecorder) ObjectRefCount(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockUniversalClient)(nil).ObjectRefCount), arg0, arg1) +} + +// PExpire mocks base method. +func (m *MockUniversalClient) PExpire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpire", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpire indicates an expected call of PExpire. +func (mr *MockUniversalClientMockRecorder) PExpire(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockUniversalClient)(nil).PExpire), arg0, arg1, arg2) +} + +// PExpireAt mocks base method. +func (m *MockUniversalClient) PExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireAt", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// PExpireAt indicates an expected call of PExpireAt. +func (mr *MockUniversalClientMockRecorder) PExpireAt(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockUniversalClient)(nil).PExpireAt), arg0, arg1, arg2) +} + +// PExpireTime mocks base method. +func (m *MockUniversalClient) PExpireTime(arg0 context.Context, arg1 string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PExpireTime", arg0, arg1) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PExpireTime indicates an expected call of PExpireTime. +func (mr *MockUniversalClientMockRecorder) PExpireTime(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockUniversalClient)(nil).PExpireTime), arg0, arg1) +} + +// PFAdd mocks base method. +func (m *MockUniversalClient) PFAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFAdd indicates an expected call of PFAdd. +func (mr *MockUniversalClientMockRecorder) PFAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockUniversalClient)(nil).PFAdd), varargs...) +} + +// PFCount mocks base method. +func (m *MockUniversalClient) PFCount(arg0 context.Context, arg1 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFCount", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PFCount indicates an expected call of PFCount. +func (mr *MockUniversalClientMockRecorder) PFCount(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockUniversalClient)(nil).PFCount), varargs...) +} + +// PFMerge mocks base method. +func (m *MockUniversalClient) PFMerge(arg0 context.Context, arg1 string, arg2 ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PFMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// PFMerge indicates an expected call of PFMerge. +func (mr *MockUniversalClientMockRecorder) PFMerge(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockUniversalClient)(nil).PFMerge), varargs...) +} + +// PSubscribe mocks base method. +func (m *MockUniversalClient) PSubscribe(arg0 context.Context, arg1 ...string) *redis.PubSub { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PSubscribe", varargs...) + ret0, _ := ret[0].(*redis.PubSub) + return ret0 +} + +// PSubscribe indicates an expected call of PSubscribe. +func (mr *MockUniversalClientMockRecorder) PSubscribe(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PSubscribe", reflect.TypeOf((*MockUniversalClient)(nil).PSubscribe), varargs...) +} + +// PTTL mocks base method. +func (m *MockUniversalClient) PTTL(arg0 context.Context, arg1 string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PTTL", arg0, arg1) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// PTTL indicates an expected call of PTTL. +func (mr *MockUniversalClientMockRecorder) PTTL(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockUniversalClient)(nil).PTTL), arg0, arg1) +} + +// Persist mocks base method. +func (m *MockUniversalClient) Persist(arg0 context.Context, arg1 string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Persist", arg0, arg1) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// Persist indicates an expected call of Persist. +func (mr *MockUniversalClientMockRecorder) Persist(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockUniversalClient)(nil).Persist), arg0, arg1) +} + +// Ping mocks base method. +func (m *MockUniversalClient) Ping(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Ping", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Ping indicates an expected call of Ping. +func (mr *MockUniversalClientMockRecorder) Ping(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockUniversalClient)(nil).Ping), arg0) +} + +// Pipeline mocks base method. +func (m *MockUniversalClient) Pipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// Pipeline indicates an expected call of Pipeline. +func (mr *MockUniversalClientMockRecorder) Pipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockUniversalClient)(nil).Pipeline)) +} + +// Pipelined mocks base method. +func (m *MockUniversalClient) Pipelined(arg0 context.Context, arg1 func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Pipelined", arg0, arg1) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Pipelined indicates an expected call of Pipelined. +func (mr *MockUniversalClientMockRecorder) Pipelined(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockUniversalClient)(nil).Pipelined), arg0, arg1) +} + +// PoolStats mocks base method. +func (m *MockUniversalClient) PoolStats() *redis.PoolStats { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PoolStats") + ret0, _ := ret[0].(*redis.PoolStats) + return ret0 +} + +// PoolStats indicates an expected call of PoolStats. +func (mr *MockUniversalClientMockRecorder) PoolStats() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PoolStats", reflect.TypeOf((*MockUniversalClient)(nil).PoolStats)) +} + +// Process mocks base method. +func (m *MockUniversalClient) Process(arg0 context.Context, arg1 redis.Cmder) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Process", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// Process indicates an expected call of Process. +func (mr *MockUniversalClientMockRecorder) Process(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Process", reflect.TypeOf((*MockUniversalClient)(nil).Process), arg0, arg1) +} + +// PubSubChannels mocks base method. +func (m *MockUniversalClient) PubSubChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubChannels", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubChannels indicates an expected call of PubSubChannels. +func (mr *MockUniversalClientMockRecorder) PubSubChannels(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockUniversalClient)(nil).PubSubChannels), arg0, arg1) +} + +// PubSubNumPat mocks base method. +func (m *MockUniversalClient) PubSubNumPat(arg0 context.Context) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubNumPat", arg0) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// PubSubNumPat indicates an expected call of PubSubNumPat. +func (mr *MockUniversalClientMockRecorder) PubSubNumPat(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockUniversalClient)(nil).PubSubNumPat), arg0) +} + +// PubSubNumSub mocks base method. +func (m *MockUniversalClient) PubSubNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubNumSub indicates an expected call of PubSubNumSub. +func (mr *MockUniversalClientMockRecorder) PubSubNumSub(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockUniversalClient)(nil).PubSubNumSub), varargs...) +} + +// PubSubShardChannels mocks base method. +func (m *MockUniversalClient) PubSubShardChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PubSubShardChannels", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// PubSubShardChannels indicates an expected call of PubSubShardChannels. +func (mr *MockUniversalClientMockRecorder) PubSubShardChannels(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockUniversalClient)(nil).PubSubShardChannels), arg0, arg1) +} + +// PubSubShardNumSub mocks base method. +func (m *MockUniversalClient) PubSubShardNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// PubSubShardNumSub indicates an expected call of PubSubShardNumSub. +func (mr *MockUniversalClientMockRecorder) PubSubShardNumSub(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockUniversalClient)(nil).PubSubShardNumSub), varargs...) +} + +// Publish mocks base method. +func (m *MockUniversalClient) Publish(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Publish", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Publish indicates an expected call of Publish. +func (mr *MockUniversalClientMockRecorder) Publish(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockUniversalClient)(nil).Publish), arg0, arg1, arg2) +} + +// Quit mocks base method. +func (m *MockUniversalClient) Quit(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Quit", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Quit indicates an expected call of Quit. +func (mr *MockUniversalClientMockRecorder) Quit(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockUniversalClient)(nil).Quit), arg0) +} + +// RPop mocks base method. +func (m *MockUniversalClient) RPop(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPop", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPop indicates an expected call of RPop. +func (mr *MockUniversalClientMockRecorder) RPop(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockUniversalClient)(nil).RPop), arg0, arg1) +} + +// RPopCount mocks base method. +func (m *MockUniversalClient) RPopCount(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopCount", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// RPopCount indicates an expected call of RPopCount. +func (mr *MockUniversalClientMockRecorder) RPopCount(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockUniversalClient)(nil).RPopCount), arg0, arg1, arg2) +} + +// RPopLPush mocks base method. +func (m *MockUniversalClient) RPopLPush(arg0 context.Context, arg1, arg2 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RPopLPush", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RPopLPush indicates an expected call of RPopLPush. +func (mr *MockUniversalClientMockRecorder) RPopLPush(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockUniversalClient)(nil).RPopLPush), arg0, arg1, arg2) +} + +// RPush mocks base method. +func (m *MockUniversalClient) RPush(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPush", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPush indicates an expected call of RPush. +func (mr *MockUniversalClientMockRecorder) RPush(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockUniversalClient)(nil).RPush), varargs...) +} + +// RPushX mocks base method. +func (m *MockUniversalClient) RPushX(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RPushX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// RPushX indicates an expected call of RPushX. +func (mr *MockUniversalClientMockRecorder) RPushX(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockUniversalClient)(nil).RPushX), varargs...) +} + +// RandomKey mocks base method. +func (m *MockUniversalClient) RandomKey(arg0 context.Context) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RandomKey", arg0) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// RandomKey indicates an expected call of RandomKey. +func (mr *MockUniversalClientMockRecorder) RandomKey(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockUniversalClient)(nil).RandomKey), arg0) +} + +// ReadOnly mocks base method. +func (m *MockUniversalClient) ReadOnly(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadOnly", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadOnly indicates an expected call of ReadOnly. +func (mr *MockUniversalClientMockRecorder) ReadOnly(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockUniversalClient)(nil).ReadOnly), arg0) +} + +// ReadWrite mocks base method. +func (m *MockUniversalClient) ReadWrite(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadWrite", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ReadWrite indicates an expected call of ReadWrite. +func (mr *MockUniversalClientMockRecorder) ReadWrite(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockUniversalClient)(nil).ReadWrite), arg0) +} + +// Rename mocks base method. +func (m *MockUniversalClient) Rename(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Rename", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Rename indicates an expected call of Rename. +func (mr *MockUniversalClientMockRecorder) Rename(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockUniversalClient)(nil).Rename), arg0, arg1, arg2) +} + +// RenameNX mocks base method. +func (m *MockUniversalClient) RenameNX(arg0 context.Context, arg1, arg2 string) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RenameNX", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// RenameNX indicates an expected call of RenameNX. +func (mr *MockUniversalClientMockRecorder) RenameNX(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockUniversalClient)(nil).RenameNX), arg0, arg1, arg2) +} + +// Restore mocks base method. +func (m *MockUniversalClient) Restore(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Restore", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Restore indicates an expected call of Restore. +func (mr *MockUniversalClientMockRecorder) Restore(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockUniversalClient)(nil).Restore), arg0, arg1, arg2, arg3) +} + +// RestoreReplace mocks base method. +func (m *MockUniversalClient) RestoreReplace(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RestoreReplace", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// RestoreReplace indicates an expected call of RestoreReplace. +func (mr *MockUniversalClientMockRecorder) RestoreReplace(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockUniversalClient)(nil).RestoreReplace), arg0, arg1, arg2, arg3) +} + +// SAdd mocks base method. +func (m *MockUniversalClient) SAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SAdd indicates an expected call of SAdd. +func (mr *MockUniversalClientMockRecorder) SAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockUniversalClient)(nil).SAdd), varargs...) +} + +// SCard mocks base method. +func (m *MockUniversalClient) SCard(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SCard", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SCard indicates an expected call of SCard. +func (mr *MockUniversalClientMockRecorder) SCard(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockUniversalClient)(nil).SCard), arg0, arg1) +} + +// SDiff mocks base method. +func (m *MockUniversalClient) SDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SDiff indicates an expected call of SDiff. +func (mr *MockUniversalClientMockRecorder) SDiff(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockUniversalClient)(nil).SDiff), varargs...) +} + +// SDiffStore mocks base method. +func (m *MockUniversalClient) SDiffStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SDiffStore indicates an expected call of SDiffStore. +func (mr *MockUniversalClientMockRecorder) SDiffStore(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockUniversalClient)(nil).SDiffStore), varargs...) +} + +// SInter mocks base method. +func (m *MockUniversalClient) SInter(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInter", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SInter indicates an expected call of SInter. +func (mr *MockUniversalClientMockRecorder) SInter(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockUniversalClient)(nil).SInter), varargs...) +} + +// SInterCard mocks base method. +func (m *MockUniversalClient) SInterCard(arg0 context.Context, arg1 int64, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterCard indicates an expected call of SInterCard. +func (mr *MockUniversalClientMockRecorder) SInterCard(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockUniversalClient)(nil).SInterCard), varargs...) +} + +// SInterStore mocks base method. +func (m *MockUniversalClient) SInterStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SInterStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SInterStore indicates an expected call of SInterStore. +func (mr *MockUniversalClientMockRecorder) SInterStore(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockUniversalClient)(nil).SInterStore), varargs...) +} + +// SIsMember mocks base method. +func (m *MockUniversalClient) SIsMember(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SIsMember", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SIsMember indicates an expected call of SIsMember. +func (mr *MockUniversalClientMockRecorder) SIsMember(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockUniversalClient)(nil).SIsMember), arg0, arg1, arg2) +} + +// SMIsMember mocks base method. +func (m *MockUniversalClient) SMIsMember(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SMIsMember", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// SMIsMember indicates an expected call of SMIsMember. +func (mr *MockUniversalClientMockRecorder) SMIsMember(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockUniversalClient)(nil).SMIsMember), varargs...) +} + +// SMembers mocks base method. +func (m *MockUniversalClient) SMembers(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembers", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SMembers indicates an expected call of SMembers. +func (mr *MockUniversalClientMockRecorder) SMembers(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockUniversalClient)(nil).SMembers), arg0, arg1) +} + +// SMembersMap mocks base method. +func (m *MockUniversalClient) SMembersMap(arg0 context.Context, arg1 string) *redis.StringStructMapCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMembersMap", arg0, arg1) + ret0, _ := ret[0].(*redis.StringStructMapCmd) + return ret0 +} + +// SMembersMap indicates an expected call of SMembersMap. +func (mr *MockUniversalClientMockRecorder) SMembersMap(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockUniversalClient)(nil).SMembersMap), arg0, arg1) +} + +// SMove mocks base method. +func (m *MockUniversalClient) SMove(arg0 context.Context, arg1, arg2 string, arg3 any) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SMove", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SMove indicates an expected call of SMove. +func (mr *MockUniversalClientMockRecorder) SMove(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockUniversalClient)(nil).SMove), arg0, arg1, arg2, arg3) +} + +// SPop mocks base method. +func (m *MockUniversalClient) SPop(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPop", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SPop indicates an expected call of SPop. +func (mr *MockUniversalClientMockRecorder) SPop(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockUniversalClient)(nil).SPop), arg0, arg1) +} + +// SPopN mocks base method. +func (m *MockUniversalClient) SPopN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPopN", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SPopN indicates an expected call of SPopN. +func (mr *MockUniversalClientMockRecorder) SPopN(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockUniversalClient)(nil).SPopN), arg0, arg1, arg2) +} + +// SPublish mocks base method. +func (m *MockUniversalClient) SPublish(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SPublish", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SPublish indicates an expected call of SPublish. +func (mr *MockUniversalClientMockRecorder) SPublish(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockUniversalClient)(nil).SPublish), arg0, arg1, arg2) +} + +// SRandMember mocks base method. +func (m *MockUniversalClient) SRandMember(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMember", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// SRandMember indicates an expected call of SRandMember. +func (mr *MockUniversalClientMockRecorder) SRandMember(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockUniversalClient)(nil).SRandMember), arg0, arg1) +} + +// SRandMemberN mocks base method. +func (m *MockUniversalClient) SRandMemberN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SRandMemberN", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SRandMemberN indicates an expected call of SRandMemberN. +func (mr *MockUniversalClientMockRecorder) SRandMemberN(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockUniversalClient)(nil).SRandMemberN), arg0, arg1, arg2) +} + +// SRem mocks base method. +func (m *MockUniversalClient) SRem(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SRem indicates an expected call of SRem. +func (mr *MockUniversalClientMockRecorder) SRem(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockUniversalClient)(nil).SRem), varargs...) +} + +// SScan mocks base method. +func (m *MockUniversalClient) SScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SScan", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// SScan indicates an expected call of SScan. +func (mr *MockUniversalClientMockRecorder) SScan(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockUniversalClient)(nil).SScan), arg0, arg1, arg2, arg3, arg4) +} + +// SSubscribe mocks base method. +func (m *MockUniversalClient) SSubscribe(arg0 context.Context, arg1 ...string) *redis.PubSub { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SSubscribe", varargs...) + ret0, _ := ret[0].(*redis.PubSub) + return ret0 +} + +// SSubscribe indicates an expected call of SSubscribe. +func (mr *MockUniversalClientMockRecorder) SSubscribe(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SSubscribe", reflect.TypeOf((*MockUniversalClient)(nil).SSubscribe), varargs...) +} + +// SUnion mocks base method. +func (m *MockUniversalClient) SUnion(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnion", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SUnion indicates an expected call of SUnion. +func (mr *MockUniversalClientMockRecorder) SUnion(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockUniversalClient)(nil).SUnion), varargs...) +} + +// SUnionStore mocks base method. +func (m *MockUniversalClient) SUnionStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SUnionStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SUnionStore indicates an expected call of SUnionStore. +func (mr *MockUniversalClientMockRecorder) SUnionStore(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockUniversalClient)(nil).SUnionStore), varargs...) +} + +// Save mocks base method. +func (m *MockUniversalClient) Save(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Save", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Save indicates an expected call of Save. +func (mr *MockUniversalClientMockRecorder) Save(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockUniversalClient)(nil).Save), arg0) +} + +// Scan mocks base method. +func (m *MockUniversalClient) Scan(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Scan", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// Scan indicates an expected call of Scan. +func (mr *MockUniversalClientMockRecorder) Scan(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockUniversalClient)(nil).Scan), arg0, arg1, arg2, arg3) +} + +// ScanType mocks base method. +func (m *MockUniversalClient) ScanType(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64, arg4 string) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScanType", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ScanType indicates an expected call of ScanType. +func (mr *MockUniversalClientMockRecorder) ScanType(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockUniversalClient)(nil).ScanType), arg0, arg1, arg2, arg3, arg4) +} + +// ScriptExists mocks base method. +func (m *MockUniversalClient) ScriptExists(arg0 context.Context, arg1 ...string) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ScriptExists", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// ScriptExists indicates an expected call of ScriptExists. +func (mr *MockUniversalClientMockRecorder) ScriptExists(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockUniversalClient)(nil).ScriptExists), varargs...) +} + +// ScriptFlush mocks base method. +func (m *MockUniversalClient) ScriptFlush(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptFlush", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptFlush indicates an expected call of ScriptFlush. +func (mr *MockUniversalClientMockRecorder) ScriptFlush(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockUniversalClient)(nil).ScriptFlush), arg0) +} + +// ScriptKill mocks base method. +func (m *MockUniversalClient) ScriptKill(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptKill", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ScriptKill indicates an expected call of ScriptKill. +func (mr *MockUniversalClientMockRecorder) ScriptKill(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockUniversalClient)(nil).ScriptKill), arg0) +} + +// ScriptLoad mocks base method. +func (m *MockUniversalClient) ScriptLoad(arg0 context.Context, arg1 string) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ScriptLoad", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// ScriptLoad indicates an expected call of ScriptLoad. +func (mr *MockUniversalClientMockRecorder) ScriptLoad(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockUniversalClient)(nil).ScriptLoad), arg0, arg1) +} + +// Set mocks base method. +func (m *MockUniversalClient) Set(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockUniversalClientMockRecorder) Set(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockUniversalClient)(nil).Set), arg0, arg1, arg2, arg3) +} + +// SetArgs mocks base method. +func (m *MockUniversalClient) SetArgs(arg0 context.Context, arg1 string, arg2 any, arg3 redis.SetArgs) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetArgs", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetArgs indicates an expected call of SetArgs. +func (mr *MockUniversalClientMockRecorder) SetArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockUniversalClient)(nil).SetArgs), arg0, arg1, arg2, arg3) +} + +// SetBit mocks base method. +func (m *MockUniversalClient) SetBit(arg0 context.Context, arg1 string, arg2 int64, arg3 int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBit", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetBit indicates an expected call of SetBit. +func (mr *MockUniversalClientMockRecorder) SetBit(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockUniversalClient)(nil).SetBit), arg0, arg1, arg2, arg3) +} + +// SetEx mocks base method. +func (m *MockUniversalClient) SetEx(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEx", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SetEx indicates an expected call of SetEx. +func (mr *MockUniversalClientMockRecorder) SetEx(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockUniversalClient)(nil).SetEx), arg0, arg1, arg2, arg3) +} + +// SetNX mocks base method. +func (m *MockUniversalClient) SetNX(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNX", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetNX indicates an expected call of SetNX. +func (mr *MockUniversalClientMockRecorder) SetNX(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockUniversalClient)(nil).SetNX), arg0, arg1, arg2, arg3) +} + +// SetRange mocks base method. +func (m *MockUniversalClient) SetRange(arg0 context.Context, arg1 string, arg2 int64, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SetRange indicates an expected call of SetRange. +func (mr *MockUniversalClientMockRecorder) SetRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockUniversalClient)(nil).SetRange), arg0, arg1, arg2, arg3) +} + +// SetXX mocks base method. +func (m *MockUniversalClient) SetXX(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.BoolCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetXX", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.BoolCmd) + return ret0 +} + +// SetXX indicates an expected call of SetXX. +func (mr *MockUniversalClientMockRecorder) SetXX(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockUniversalClient)(nil).SetXX), arg0, arg1, arg2, arg3) +} + +// Shutdown mocks base method. +func (m *MockUniversalClient) Shutdown(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Shutdown", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Shutdown indicates an expected call of Shutdown. +func (mr *MockUniversalClientMockRecorder) Shutdown(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockUniversalClient)(nil).Shutdown), arg0) +} + +// ShutdownNoSave mocks base method. +func (m *MockUniversalClient) ShutdownNoSave(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownNoSave", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownNoSave indicates an expected call of ShutdownNoSave. +func (mr *MockUniversalClientMockRecorder) ShutdownNoSave(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockUniversalClient)(nil).ShutdownNoSave), arg0) +} + +// ShutdownSave mocks base method. +func (m *MockUniversalClient) ShutdownSave(arg0 context.Context) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ShutdownSave", arg0) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// ShutdownSave indicates an expected call of ShutdownSave. +func (mr *MockUniversalClientMockRecorder) ShutdownSave(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockUniversalClient)(nil).ShutdownSave), arg0) +} + +// SlaveOf mocks base method. +func (m *MockUniversalClient) SlaveOf(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlaveOf", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// SlaveOf indicates an expected call of SlaveOf. +func (mr *MockUniversalClientMockRecorder) SlaveOf(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockUniversalClient)(nil).SlaveOf), arg0, arg1, arg2) +} + +// SlowLogGet mocks base method. +func (m *MockUniversalClient) SlowLogGet(arg0 context.Context, arg1 int64) *redis.SlowLogCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SlowLogGet", arg0, arg1) + ret0, _ := ret[0].(*redis.SlowLogCmd) + return ret0 +} + +// SlowLogGet indicates an expected call of SlowLogGet. +func (mr *MockUniversalClientMockRecorder) SlowLogGet(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockUniversalClient)(nil).SlowLogGet), arg0, arg1) +} + +// Sort mocks base method. +func (m *MockUniversalClient) Sort(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Sort", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// Sort indicates an expected call of Sort. +func (mr *MockUniversalClientMockRecorder) Sort(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockUniversalClient)(nil).Sort), arg0, arg1, arg2) +} + +// SortInterfaces mocks base method. +func (m *MockUniversalClient) SortInterfaces(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.SliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortInterfaces", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.SliceCmd) + return ret0 +} + +// SortInterfaces indicates an expected call of SortInterfaces. +func (mr *MockUniversalClientMockRecorder) SortInterfaces(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockUniversalClient)(nil).SortInterfaces), arg0, arg1, arg2) +} + +// SortRO mocks base method. +func (m *MockUniversalClient) SortRO(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortRO", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// SortRO indicates an expected call of SortRO. +func (mr *MockUniversalClientMockRecorder) SortRO(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockUniversalClient)(nil).SortRO), arg0, arg1, arg2) +} + +// SortStore mocks base method. +func (m *MockUniversalClient) SortStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.Sort) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SortStore", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// SortStore indicates an expected call of SortStore. +func (mr *MockUniversalClientMockRecorder) SortStore(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockUniversalClient)(nil).SortStore), arg0, arg1, arg2, arg3) +} + +// StrLen mocks base method. +func (m *MockUniversalClient) StrLen(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StrLen", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// StrLen indicates an expected call of StrLen. +func (mr *MockUniversalClientMockRecorder) StrLen(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockUniversalClient)(nil).StrLen), arg0, arg1) +} + +// Subscribe mocks base method. +func (m *MockUniversalClient) Subscribe(arg0 context.Context, arg1 ...string) *redis.PubSub { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Subscribe", varargs...) + ret0, _ := ret[0].(*redis.PubSub) + return ret0 +} + +// Subscribe indicates an expected call of Subscribe. +func (mr *MockUniversalClientMockRecorder) Subscribe(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockUniversalClient)(nil).Subscribe), varargs...) +} + +// TDigestAdd mocks base method. +func (m *MockUniversalClient) TDigestAdd(arg0 context.Context, arg1 string, arg2 ...float64) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestAdd", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestAdd indicates an expected call of TDigestAdd. +func (mr *MockUniversalClientMockRecorder) TDigestAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockUniversalClient)(nil).TDigestAdd), varargs...) +} + +// TDigestByRank mocks base method. +func (m *MockUniversalClient) TDigestByRank(arg0 context.Context, arg1 string, arg2 ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRank indicates an expected call of TDigestByRank. +func (mr *MockUniversalClientMockRecorder) TDigestByRank(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestByRank), varargs...) +} + +// TDigestByRevRank mocks base method. +func (m *MockUniversalClient) TDigestByRevRank(arg0 context.Context, arg1 string, arg2 ...uint64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestByRevRank", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestByRevRank indicates an expected call of TDigestByRevRank. +func (mr *MockUniversalClientMockRecorder) TDigestByRevRank(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestByRevRank), varargs...) +} + +// TDigestCDF mocks base method. +func (m *MockUniversalClient) TDigestCDF(arg0 context.Context, arg1 string, arg2 ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestCDF", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestCDF indicates an expected call of TDigestCDF. +func (mr *MockUniversalClientMockRecorder) TDigestCDF(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCDF), varargs...) +} + +// TDigestCreate mocks base method. +func (m *MockUniversalClient) TDigestCreate(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreate", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreate indicates an expected call of TDigestCreate. +func (mr *MockUniversalClientMockRecorder) TDigestCreate(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCreate), arg0, arg1) +} + +// TDigestCreateWithCompression mocks base method. +func (m *MockUniversalClient) TDigestCreateWithCompression(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestCreateWithCompression", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression. +func (mr *MockUniversalClientMockRecorder) TDigestCreateWithCompression(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockUniversalClient)(nil).TDigestCreateWithCompression), arg0, arg1, arg2) +} + +// TDigestInfo mocks base method. +func (m *MockUniversalClient) TDigestInfo(arg0 context.Context, arg1 string) *redis.TDigestInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.TDigestInfoCmd) + return ret0 +} + +// TDigestInfo indicates an expected call of TDigestInfo. +func (mr *MockUniversalClientMockRecorder) TDigestInfo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockUniversalClient)(nil).TDigestInfo), arg0, arg1) +} + +// TDigestMax mocks base method. +func (m *MockUniversalClient) TDigestMax(arg0 context.Context, arg1 string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMax", arg0, arg1) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMax indicates an expected call of TDigestMax. +func (mr *MockUniversalClientMockRecorder) TDigestMax(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMax), arg0, arg1) +} + +// TDigestMerge mocks base method. +func (m *MockUniversalClient) TDigestMerge(arg0 context.Context, arg1 string, arg2 *redis.TDigestMergeOptions, arg3 ...string) *redis.StatusCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestMerge", varargs...) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestMerge indicates an expected call of TDigestMerge. +func (mr *MockUniversalClientMockRecorder) TDigestMerge(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMerge), varargs...) +} + +// TDigestMin mocks base method. +func (m *MockUniversalClient) TDigestMin(arg0 context.Context, arg1 string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestMin", arg0, arg1) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestMin indicates an expected call of TDigestMin. +func (mr *MockUniversalClientMockRecorder) TDigestMin(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockUniversalClient)(nil).TDigestMin), arg0, arg1) +} + +// TDigestQuantile mocks base method. +func (m *MockUniversalClient) TDigestQuantile(arg0 context.Context, arg1 string, arg2 ...float64) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestQuantile", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// TDigestQuantile indicates an expected call of TDigestQuantile. +func (mr *MockUniversalClientMockRecorder) TDigestQuantile(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockUniversalClient)(nil).TDigestQuantile), varargs...) +} + +// TDigestRank mocks base method. +func (m *MockUniversalClient) TDigestRank(arg0 context.Context, arg1 string, arg2 ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRank indicates an expected call of TDigestRank. +func (mr *MockUniversalClientMockRecorder) TDigestRank(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestRank), varargs...) +} + +// TDigestReset mocks base method. +func (m *MockUniversalClient) TDigestReset(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestReset", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TDigestReset indicates an expected call of TDigestReset. +func (mr *MockUniversalClientMockRecorder) TDigestReset(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockUniversalClient)(nil).TDigestReset), arg0, arg1) +} + +// TDigestRevRank mocks base method. +func (m *MockUniversalClient) TDigestRevRank(arg0 context.Context, arg1 string, arg2 ...float64) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TDigestRevRank", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TDigestRevRank indicates an expected call of TDigestRevRank. +func (mr *MockUniversalClientMockRecorder) TDigestRevRank(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockUniversalClient)(nil).TDigestRevRank), varargs...) +} + +// TDigestTrimmedMean mocks base method. +func (m *MockUniversalClient) TDigestTrimmedMean(arg0 context.Context, arg1 string, arg2, arg3 float64) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TDigestTrimmedMean", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean. +func (mr *MockUniversalClientMockRecorder) TDigestTrimmedMean(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockUniversalClient)(nil).TDigestTrimmedMean), arg0, arg1, arg2, arg3) +} + +// TFCall mocks base method. +func (m *MockUniversalClient) TFCall(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCall", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCall indicates an expected call of TFCall. +func (mr *MockUniversalClientMockRecorder) TFCall(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockUniversalClient)(nil).TFCall), arg0, arg1, arg2, arg3) +} + +// TFCallASYNC mocks base method. +func (m *MockUniversalClient) TFCallASYNC(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNC", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNC indicates an expected call of TFCallASYNC. +func (mr *MockUniversalClientMockRecorder) TFCallASYNC(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockUniversalClient)(nil).TFCallASYNC), arg0, arg1, arg2, arg3) +} + +// TFCallASYNCArgs mocks base method. +func (m *MockUniversalClient) TFCallASYNCArgs(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallASYNCArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs. +func (mr *MockUniversalClientMockRecorder) TFCallASYNCArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFCallASYNCArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TFCallArgs mocks base method. +func (m *MockUniversalClient) TFCallArgs(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 *redis.TFCallOptions) *redis.Cmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFCallArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.Cmd) + return ret0 +} + +// TFCallArgs indicates an expected call of TFCallArgs. +func (mr *MockUniversalClientMockRecorder) TFCallArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFCallArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TFunctionDelete mocks base method. +func (m *MockUniversalClient) TFunctionDelete(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionDelete", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionDelete indicates an expected call of TFunctionDelete. +func (mr *MockUniversalClientMockRecorder) TFunctionDelete(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionDelete), arg0, arg1) +} + +// TFunctionList mocks base method. +func (m *MockUniversalClient) TFunctionList(arg0 context.Context) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionList", arg0) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionList indicates an expected call of TFunctionList. +func (mr *MockUniversalClientMockRecorder) TFunctionList(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionList), arg0) +} + +// TFunctionListArgs mocks base method. +func (m *MockUniversalClient) TFunctionListArgs(arg0 context.Context, arg1 *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionListArgs", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd) + return ret0 +} + +// TFunctionListArgs indicates an expected call of TFunctionListArgs. +func (mr *MockUniversalClientMockRecorder) TFunctionListArgs(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionListArgs), arg0, arg1) +} + +// TFunctionLoad mocks base method. +func (m *MockUniversalClient) TFunctionLoad(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoad", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoad indicates an expected call of TFunctionLoad. +func (mr *MockUniversalClientMockRecorder) TFunctionLoad(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionLoad), arg0, arg1) +} + +// TFunctionLoadArgs mocks base method. +func (m *MockUniversalClient) TFunctionLoadArgs(arg0 context.Context, arg1 string, arg2 *redis.TFunctionLoadOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TFunctionLoadArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs. +func (mr *MockUniversalClientMockRecorder) TFunctionLoadArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockUniversalClient)(nil).TFunctionLoadArgs), arg0, arg1, arg2) +} + +// TSAdd mocks base method. +func (m *MockUniversalClient) TSAdd(arg0 context.Context, arg1 string, arg2 any, arg3 float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAdd", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSAdd indicates an expected call of TSAdd. +func (mr *MockUniversalClientMockRecorder) TSAdd(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockUniversalClient)(nil).TSAdd), arg0, arg1, arg2, arg3) +} + +// TSAddWithArgs mocks base method. +func (m *MockUniversalClient) TSAddWithArgs(arg0 context.Context, arg1 string, arg2 any, arg3 float64, arg4 *redis.TSOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAddWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSAddWithArgs indicates an expected call of TSAddWithArgs. +func (mr *MockUniversalClientMockRecorder) TSAddWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSAddWithArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TSAlter mocks base method. +func (m *MockUniversalClient) TSAlter(arg0 context.Context, arg1 string, arg2 *redis.TSAlterOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSAlter", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSAlter indicates an expected call of TSAlter. +func (mr *MockUniversalClientMockRecorder) TSAlter(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockUniversalClient)(nil).TSAlter), arg0, arg1, arg2) +} + +// TSCreate mocks base method. +func (m *MockUniversalClient) TSCreate(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreate", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreate indicates an expected call of TSCreate. +func (mr *MockUniversalClientMockRecorder) TSCreate(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreate", reflect.TypeOf((*MockUniversalClient)(nil).TSCreate), arg0, arg1) +} + +// TSCreateRule mocks base method. +func (m *MockUniversalClient) TSCreateRule(arg0 context.Context, arg1, arg2 string, arg3 redis.Aggregator, arg4 int) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateRule", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateRule indicates an expected call of TSCreateRule. +func (mr *MockUniversalClientMockRecorder) TSCreateRule(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateRule), arg0, arg1, arg2, arg3, arg4) +} + +// TSCreateRuleWithArgs mocks base method. +func (m *MockUniversalClient) TSCreateRuleWithArgs(arg0 context.Context, arg1, arg2 string, arg3 redis.Aggregator, arg4 int, arg5 *redis.TSCreateRuleOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", arg0, arg1, arg2, arg3, arg4, arg5) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs. +func (mr *MockUniversalClientMockRecorder) TSCreateRuleWithArgs(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateRuleWithArgs), arg0, arg1, arg2, arg3, arg4, arg5) +} + +// TSCreateWithArgs mocks base method. +func (m *MockUniversalClient) TSCreateWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSOptions) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSCreateWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSCreateWithArgs indicates an expected call of TSCreateWithArgs. +func (mr *MockUniversalClientMockRecorder) TSCreateWithArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSCreateWithArgs), arg0, arg1, arg2) +} + +// TSDecrBy mocks base method. +func (m *MockUniversalClient) TSDecrBy(arg0 context.Context, arg1 string, arg2 float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDecrBy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDecrBy indicates an expected call of TSDecrBy. +func (mr *MockUniversalClientMockRecorder) TSDecrBy(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockUniversalClient)(nil).TSDecrBy), arg0, arg1, arg2) +} + +// TSDecrByWithArgs mocks base method. +func (m *MockUniversalClient) TSDecrByWithArgs(arg0 context.Context, arg1 string, arg2 float64, arg3 *redis.TSIncrDecrOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDecrByWithArgs", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs. +func (mr *MockUniversalClientMockRecorder) TSDecrByWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSDecrByWithArgs), arg0, arg1, arg2, arg3) +} + +// TSDel mocks base method. +func (m *MockUniversalClient) TSDel(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDel", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSDel indicates an expected call of TSDel. +func (mr *MockUniversalClientMockRecorder) TSDel(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockUniversalClient)(nil).TSDel), arg0, arg1, arg2, arg3) +} + +// TSDeleteRule mocks base method. +func (m *MockUniversalClient) TSDeleteRule(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSDeleteRule", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TSDeleteRule indicates an expected call of TSDeleteRule. +func (mr *MockUniversalClientMockRecorder) TSDeleteRule(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockUniversalClient)(nil).TSDeleteRule), arg0, arg1, arg2) +} + +// TSGet mocks base method. +func (m *MockUniversalClient) TSGet(arg0 context.Context, arg1 string) *redis.TSTimestampValueCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSGet", arg0, arg1) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) + return ret0 +} + +// TSGet indicates an expected call of TSGet. +func (mr *MockUniversalClientMockRecorder) TSGet(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGet", reflect.TypeOf((*MockUniversalClient)(nil).TSGet), arg0, arg1) +} + +// TSGetWithArgs mocks base method. +func (m *MockUniversalClient) TSGetWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSGetOptions) *redis.TSTimestampValueCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSGetWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.TSTimestampValueCmd) + return ret0 +} + +// TSGetWithArgs indicates an expected call of TSGetWithArgs. +func (mr *MockUniversalClientMockRecorder) TSGetWithArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSGetWithArgs), arg0, arg1, arg2) +} + +// TSIncrBy mocks base method. +func (m *MockUniversalClient) TSIncrBy(arg0 context.Context, arg1 string, arg2 float64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSIncrBy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSIncrBy indicates an expected call of TSIncrBy. +func (mr *MockUniversalClientMockRecorder) TSIncrBy(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).TSIncrBy), arg0, arg1, arg2) +} + +// TSIncrByWithArgs mocks base method. +func (m *MockUniversalClient) TSIncrByWithArgs(arg0 context.Context, arg1 string, arg2 float64, arg3 *redis.TSIncrDecrOptions) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSIncrByWithArgs", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs. +func (mr *MockUniversalClientMockRecorder) TSIncrByWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSIncrByWithArgs), arg0, arg1, arg2, arg3) +} + +// TSInfo mocks base method. +func (m *MockUniversalClient) TSInfo(arg0 context.Context, arg1 string) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// TSInfo indicates an expected call of TSInfo. +func (mr *MockUniversalClientMockRecorder) TSInfo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfo", reflect.TypeOf((*MockUniversalClient)(nil).TSInfo), arg0, arg1) +} + +// TSInfoWithArgs mocks base method. +func (m *MockUniversalClient) TSInfoWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSInfoOptions) *redis.MapStringInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSInfoWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.MapStringInterfaceCmd) + return ret0 +} + +// TSInfoWithArgs indicates an expected call of TSInfoWithArgs. +func (mr *MockUniversalClientMockRecorder) TSInfoWithArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSInfoWithArgs), arg0, arg1, arg2) +} + +// TSMAdd mocks base method. +func (m *MockUniversalClient) TSMAdd(arg0 context.Context, arg1 [][]any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMAdd", arg0, arg1) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TSMAdd indicates an expected call of TSMAdd. +func (mr *MockUniversalClientMockRecorder) TSMAdd(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockUniversalClient)(nil).TSMAdd), arg0, arg1) +} + +// TSMGet mocks base method. +func (m *MockUniversalClient) TSMGet(arg0 context.Context, arg1 []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMGet", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMGet indicates an expected call of TSMGet. +func (mr *MockUniversalClientMockRecorder) TSMGet(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockUniversalClient)(nil).TSMGet), arg0, arg1) +} + +// TSMGetWithArgs mocks base method. +func (m *MockUniversalClient) TSMGetWithArgs(arg0 context.Context, arg1 []string, arg2 *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMGetWithArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMGetWithArgs indicates an expected call of TSMGetWithArgs. +func (mr *MockUniversalClientMockRecorder) TSMGetWithArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMGetWithArgs), arg0, arg1, arg2) +} + +// TSMRange mocks base method. +func (m *MockUniversalClient) TSMRange(arg0 context.Context, arg1, arg2 int, arg3 []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRange indicates an expected call of TSMRange. +func (mr *MockUniversalClientMockRecorder) TSMRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockUniversalClient)(nil).TSMRange), arg0, arg1, arg2, arg3) +} + +// TSMRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSMRangeWithArgs(arg0 context.Context, arg1, arg2 int, arg3 []string, arg4 *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSMRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMRangeWithArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TSMRevRange mocks base method. +func (m *MockUniversalClient) TSMRevRange(arg0 context.Context, arg1, arg2 int, arg3 []string) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRevRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRevRange indicates an expected call of TSMRevRange. +func (mr *MockUniversalClientMockRecorder) TSMRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockUniversalClient)(nil).TSMRevRange), arg0, arg1, arg2, arg3) +} + +// TSMRevRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSMRevRangeWithArgs(arg0 context.Context, arg1, arg2 int, arg3 []string, arg4 *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd) + return ret0 +} + +// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSMRevRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSMRevRangeWithArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TSQueryIndex mocks base method. +func (m *MockUniversalClient) TSQueryIndex(arg0 context.Context, arg1 []string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSQueryIndex", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TSQueryIndex indicates an expected call of TSQueryIndex. +func (mr *MockUniversalClientMockRecorder) TSQueryIndex(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockUniversalClient)(nil).TSQueryIndex), arg0, arg1) +} + +// TSRange mocks base method. +func (m *MockUniversalClient) TSRange(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRange indicates an expected call of TSRange. +func (mr *MockUniversalClientMockRecorder) TSRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockUniversalClient)(nil).TSRange), arg0, arg1, arg2, arg3) +} + +// TSRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSRangeWithArgs(arg0 context.Context, arg1 string, arg2, arg3 int, arg4 *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRangeWithArgs indicates an expected call of TSRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSRangeWithArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TSRevRange mocks base method. +func (m *MockUniversalClient) TSRevRange(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRevRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRevRange indicates an expected call of TSRevRange. +func (mr *MockUniversalClientMockRecorder) TSRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockUniversalClient)(nil).TSRevRange), arg0, arg1, arg2, arg3) +} + +// TSRevRangeWithArgs mocks base method. +func (m *MockUniversalClient) TSRevRangeWithArgs(arg0 context.Context, arg1 string, arg2, arg3 int, arg4 *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TSRevRangeWithArgs", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd) + return ret0 +} + +// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs. +func (mr *MockUniversalClientMockRecorder) TSRevRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockUniversalClient)(nil).TSRevRangeWithArgs), arg0, arg1, arg2, arg3, arg4) +} + +// TTL mocks base method. +func (m *MockUniversalClient) TTL(arg0 context.Context, arg1 string) *redis.DurationCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TTL", arg0, arg1) + ret0, _ := ret[0].(*redis.DurationCmd) + return ret0 +} + +// TTL indicates an expected call of TTL. +func (mr *MockUniversalClientMockRecorder) TTL(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockUniversalClient)(nil).TTL), arg0, arg1) +} + +// Time mocks base method. +func (m *MockUniversalClient) Time(arg0 context.Context) *redis.TimeCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Time", arg0) + ret0, _ := ret[0].(*redis.TimeCmd) + return ret0 +} + +// Time indicates an expected call of Time. +func (mr *MockUniversalClientMockRecorder) Time(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockUniversalClient)(nil).Time), arg0) +} + +// TopKAdd mocks base method. +func (m *MockUniversalClient) TopKAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKAdd", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKAdd indicates an expected call of TopKAdd. +func (mr *MockUniversalClientMockRecorder) TopKAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockUniversalClient)(nil).TopKAdd), varargs...) +} + +// TopKCount mocks base method. +func (m *MockUniversalClient) TopKCount(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKCount", varargs...) + ret0, _ := ret[0].(*redis.IntSliceCmd) + return ret0 +} + +// TopKCount indicates an expected call of TopKCount. +func (mr *MockUniversalClientMockRecorder) TopKCount(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockUniversalClient)(nil).TopKCount), varargs...) +} + +// TopKIncrBy mocks base method. +func (m *MockUniversalClient) TopKIncrBy(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKIncrBy", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKIncrBy indicates an expected call of TopKIncrBy. +func (mr *MockUniversalClientMockRecorder) TopKIncrBy(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).TopKIncrBy), varargs...) +} + +// TopKInfo mocks base method. +func (m *MockUniversalClient) TopKInfo(arg0 context.Context, arg1 string) *redis.TopKInfoCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKInfo", arg0, arg1) + ret0, _ := ret[0].(*redis.TopKInfoCmd) + return ret0 +} + +// TopKInfo indicates an expected call of TopKInfo. +func (mr *MockUniversalClientMockRecorder) TopKInfo(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockUniversalClient)(nil).TopKInfo), arg0, arg1) +} + +// TopKList mocks base method. +func (m *MockUniversalClient) TopKList(arg0 context.Context, arg1 string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKList", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// TopKList indicates an expected call of TopKList. +func (mr *MockUniversalClientMockRecorder) TopKList(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockUniversalClient)(nil).TopKList), arg0, arg1) +} + +// TopKListWithCount mocks base method. +func (m *MockUniversalClient) TopKListWithCount(arg0 context.Context, arg1 string) *redis.MapStringIntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKListWithCount", arg0, arg1) + ret0, _ := ret[0].(*redis.MapStringIntCmd) + return ret0 +} + +// TopKListWithCount indicates an expected call of TopKListWithCount. +func (mr *MockUniversalClientMockRecorder) TopKListWithCount(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockUniversalClient)(nil).TopKListWithCount), arg0, arg1) +} + +// TopKQuery mocks base method. +func (m *MockUniversalClient) TopKQuery(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TopKQuery", varargs...) + ret0, _ := ret[0].(*redis.BoolSliceCmd) + return ret0 +} + +// TopKQuery indicates an expected call of TopKQuery. +func (mr *MockUniversalClientMockRecorder) TopKQuery(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockUniversalClient)(nil).TopKQuery), varargs...) +} + +// TopKReserve mocks base method. +func (m *MockUniversalClient) TopKReserve(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserve", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserve indicates an expected call of TopKReserve. +func (mr *MockUniversalClientMockRecorder) TopKReserve(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockUniversalClient)(nil).TopKReserve), arg0, arg1, arg2) +} + +// TopKReserveWithOptions mocks base method. +func (m *MockUniversalClient) TopKReserveWithOptions(arg0 context.Context, arg1 string, arg2, arg3, arg4 int64, arg5 float64) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TopKReserveWithOptions", arg0, arg1, arg2, arg3, arg4, arg5) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// TopKReserveWithOptions indicates an expected call of TopKReserveWithOptions. +func (mr *MockUniversalClientMockRecorder) TopKReserveWithOptions(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserveWithOptions", reflect.TypeOf((*MockUniversalClient)(nil).TopKReserveWithOptions), arg0, arg1, arg2, arg3, arg4, arg5) +} + +// Touch mocks base method. +func (m *MockUniversalClient) Touch(arg0 context.Context, arg1 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Touch", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Touch indicates an expected call of Touch. +func (mr *MockUniversalClientMockRecorder) Touch(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockUniversalClient)(nil).Touch), varargs...) +} + +// TxPipeline mocks base method. +func (m *MockUniversalClient) TxPipeline() redis.Pipeliner { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipeline") + ret0, _ := ret[0].(redis.Pipeliner) + return ret0 +} + +// TxPipeline indicates an expected call of TxPipeline. +func (mr *MockUniversalClientMockRecorder) TxPipeline() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipeline", reflect.TypeOf((*MockUniversalClient)(nil).TxPipeline)) +} + +// TxPipelined mocks base method. +func (m *MockUniversalClient) TxPipelined(arg0 context.Context, arg1 func(redis.Pipeliner) error) ([]redis.Cmder, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TxPipelined", arg0, arg1) + ret0, _ := ret[0].([]redis.Cmder) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TxPipelined indicates an expected call of TxPipelined. +func (mr *MockUniversalClientMockRecorder) TxPipelined(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockUniversalClient)(nil).TxPipelined), arg0, arg1) +} + +// Type mocks base method. +func (m *MockUniversalClient) Type(arg0 context.Context, arg1 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Type", arg0, arg1) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// Type indicates an expected call of Type. +func (mr *MockUniversalClientMockRecorder) Type(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockUniversalClient)(nil).Type), arg0, arg1) +} + +// Unlink mocks base method. +func (m *MockUniversalClient) Unlink(arg0 context.Context, arg1 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Unlink", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// Unlink indicates an expected call of Unlink. +func (mr *MockUniversalClientMockRecorder) Unlink(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockUniversalClient)(nil).Unlink), varargs...) +} + +// Watch mocks base method. +func (m *MockUniversalClient) Watch(arg0 context.Context, arg1 func(*redis.Tx) error, arg2 ...string) error { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Watch", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// Watch indicates an expected call of Watch. +func (mr *MockUniversalClientMockRecorder) Watch(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockUniversalClient)(nil).Watch), varargs...) +} + +// XAck mocks base method. +func (m *MockUniversalClient) XAck(arg0 context.Context, arg1, arg2 string, arg3 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XAck", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XAck indicates an expected call of XAck. +func (mr *MockUniversalClientMockRecorder) XAck(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockUniversalClient)(nil).XAck), varargs...) +} + +// XAdd mocks base method. +func (m *MockUniversalClient) XAdd(arg0 context.Context, arg1 *redis.XAddArgs) *redis.StringCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAdd", arg0, arg1) + ret0, _ := ret[0].(*redis.StringCmd) + return ret0 +} + +// XAdd indicates an expected call of XAdd. +func (mr *MockUniversalClientMockRecorder) XAdd(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockUniversalClient)(nil).XAdd), arg0, arg1) +} + +// XAutoClaim mocks base method. +func (m *MockUniversalClient) XAutoClaim(arg0 context.Context, arg1 *redis.XAutoClaimArgs) *redis.XAutoClaimCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaim", arg0, arg1) + ret0, _ := ret[0].(*redis.XAutoClaimCmd) + return ret0 +} + +// XAutoClaim indicates an expected call of XAutoClaim. +func (mr *MockUniversalClientMockRecorder) XAutoClaim(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockUniversalClient)(nil).XAutoClaim), arg0, arg1) +} + +// XAutoClaimJustID mocks base method. +func (m *MockUniversalClient) XAutoClaimJustID(arg0 context.Context, arg1 *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XAutoClaimJustID", arg0, arg1) + ret0, _ := ret[0].(*redis.XAutoClaimJustIDCmd) + return ret0 +} + +// XAutoClaimJustID indicates an expected call of XAutoClaimJustID. +func (mr *MockUniversalClientMockRecorder) XAutoClaimJustID(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockUniversalClient)(nil).XAutoClaimJustID), arg0, arg1) +} + +// XClaim mocks base method. +func (m *MockUniversalClient) XClaim(arg0 context.Context, arg1 *redis.XClaimArgs) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaim", arg0, arg1) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XClaim indicates an expected call of XClaim. +func (mr *MockUniversalClientMockRecorder) XClaim(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockUniversalClient)(nil).XClaim), arg0, arg1) +} + +// XClaimJustID mocks base method. +func (m *MockUniversalClient) XClaimJustID(arg0 context.Context, arg1 *redis.XClaimArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XClaimJustID", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// XClaimJustID indicates an expected call of XClaimJustID. +func (mr *MockUniversalClientMockRecorder) XClaimJustID(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockUniversalClient)(nil).XClaimJustID), arg0, arg1) +} + +// XDel mocks base method. +func (m *MockUniversalClient) XDel(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XDel", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XDel indicates an expected call of XDel. +func (mr *MockUniversalClientMockRecorder) XDel(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockUniversalClient)(nil).XDel), varargs...) +} + +// XGroupCreate mocks base method. +func (m *MockUniversalClient) XGroupCreate(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreate", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreate indicates an expected call of XGroupCreate. +func (mr *MockUniversalClientMockRecorder) XGroupCreate(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreate), arg0, arg1, arg2, arg3) +} + +// XGroupCreateConsumer mocks base method. +func (m *MockUniversalClient) XGroupCreateConsumer(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateConsumer", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer. +func (mr *MockUniversalClientMockRecorder) XGroupCreateConsumer(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreateConsumer), arg0, arg1, arg2, arg3) +} + +// XGroupCreateMkStream mocks base method. +func (m *MockUniversalClient) XGroupCreateMkStream(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupCreateMkStream", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream. +func (mr *MockUniversalClientMockRecorder) XGroupCreateMkStream(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockUniversalClient)(nil).XGroupCreateMkStream), arg0, arg1, arg2, arg3) +} + +// XGroupDelConsumer mocks base method. +func (m *MockUniversalClient) XGroupDelConsumer(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDelConsumer", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDelConsumer indicates an expected call of XGroupDelConsumer. +func (mr *MockUniversalClientMockRecorder) XGroupDelConsumer(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockUniversalClient)(nil).XGroupDelConsumer), arg0, arg1, arg2, arg3) +} + +// XGroupDestroy mocks base method. +func (m *MockUniversalClient) XGroupDestroy(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupDestroy", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XGroupDestroy indicates an expected call of XGroupDestroy. +func (mr *MockUniversalClientMockRecorder) XGroupDestroy(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockUniversalClient)(nil).XGroupDestroy), arg0, arg1, arg2) +} + +// XGroupSetID mocks base method. +func (m *MockUniversalClient) XGroupSetID(arg0 context.Context, arg1, arg2, arg3 string) *redis.StatusCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XGroupSetID", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StatusCmd) + return ret0 +} + +// XGroupSetID indicates an expected call of XGroupSetID. +func (mr *MockUniversalClientMockRecorder) XGroupSetID(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockUniversalClient)(nil).XGroupSetID), arg0, arg1, arg2, arg3) +} + +// XInfoConsumers mocks base method. +func (m *MockUniversalClient) XInfoConsumers(arg0 context.Context, arg1, arg2 string) *redis.XInfoConsumersCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoConsumers", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.XInfoConsumersCmd) + return ret0 +} + +// XInfoConsumers indicates an expected call of XInfoConsumers. +func (mr *MockUniversalClientMockRecorder) XInfoConsumers(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockUniversalClient)(nil).XInfoConsumers), arg0, arg1, arg2) +} + +// XInfoGroups mocks base method. +func (m *MockUniversalClient) XInfoGroups(arg0 context.Context, arg1 string) *redis.XInfoGroupsCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoGroups", arg0, arg1) + ret0, _ := ret[0].(*redis.XInfoGroupsCmd) + return ret0 +} + +// XInfoGroups indicates an expected call of XInfoGroups. +func (mr *MockUniversalClientMockRecorder) XInfoGroups(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockUniversalClient)(nil).XInfoGroups), arg0, arg1) +} + +// XInfoStream mocks base method. +func (m *MockUniversalClient) XInfoStream(arg0 context.Context, arg1 string) *redis.XInfoStreamCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStream", arg0, arg1) + ret0, _ := ret[0].(*redis.XInfoStreamCmd) + return ret0 +} + +// XInfoStream indicates an expected call of XInfoStream. +func (mr *MockUniversalClientMockRecorder) XInfoStream(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockUniversalClient)(nil).XInfoStream), arg0, arg1) +} + +// XInfoStreamFull mocks base method. +func (m *MockUniversalClient) XInfoStreamFull(arg0 context.Context, arg1 string, arg2 int) *redis.XInfoStreamFullCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XInfoStreamFull", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.XInfoStreamFullCmd) + return ret0 +} + +// XInfoStreamFull indicates an expected call of XInfoStreamFull. +func (mr *MockUniversalClientMockRecorder) XInfoStreamFull(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockUniversalClient)(nil).XInfoStreamFull), arg0, arg1, arg2) +} + +// XLen mocks base method. +func (m *MockUniversalClient) XLen(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XLen", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XLen indicates an expected call of XLen. +func (mr *MockUniversalClientMockRecorder) XLen(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockUniversalClient)(nil).XLen), arg0, arg1) +} + +// XPending mocks base method. +func (m *MockUniversalClient) XPending(arg0 context.Context, arg1, arg2 string) *redis.XPendingCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPending", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.XPendingCmd) + return ret0 +} + +// XPending indicates an expected call of XPending. +func (mr *MockUniversalClientMockRecorder) XPending(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockUniversalClient)(nil).XPending), arg0, arg1, arg2) +} + +// XPendingExt mocks base method. +func (m *MockUniversalClient) XPendingExt(arg0 context.Context, arg1 *redis.XPendingExtArgs) *redis.XPendingExtCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XPendingExt", arg0, arg1) + ret0, _ := ret[0].(*redis.XPendingExtCmd) + return ret0 +} + +// XPendingExt indicates an expected call of XPendingExt. +func (mr *MockUniversalClientMockRecorder) XPendingExt(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockUniversalClient)(nil).XPendingExt), arg0, arg1) +} + +// XRange mocks base method. +func (m *MockUniversalClient) XRange(arg0 context.Context, arg1, arg2, arg3 string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRange indicates an expected call of XRange. +func (mr *MockUniversalClientMockRecorder) XRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockUniversalClient)(nil).XRange), arg0, arg1, arg2, arg3) +} + +// XRangeN mocks base method. +func (m *MockUniversalClient) XRangeN(arg0 context.Context, arg1, arg2, arg3 string, arg4 int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRangeN", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRangeN indicates an expected call of XRangeN. +func (mr *MockUniversalClientMockRecorder) XRangeN(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockUniversalClient)(nil).XRangeN), arg0, arg1, arg2, arg3, arg4) +} + +// XRead mocks base method. +func (m *MockUniversalClient) XRead(arg0 context.Context, arg1 *redis.XReadArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRead", arg0, arg1) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XRead indicates an expected call of XRead. +func (mr *MockUniversalClientMockRecorder) XRead(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockUniversalClient)(nil).XRead), arg0, arg1) +} + +// XReadGroup mocks base method. +func (m *MockUniversalClient) XReadGroup(arg0 context.Context, arg1 *redis.XReadGroupArgs) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XReadGroup", arg0, arg1) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadGroup indicates an expected call of XReadGroup. +func (mr *MockUniversalClientMockRecorder) XReadGroup(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockUniversalClient)(nil).XReadGroup), arg0, arg1) +} + +// XReadStreams mocks base method. +func (m *MockUniversalClient) XReadStreams(arg0 context.Context, arg1 ...string) *redis.XStreamSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "XReadStreams", varargs...) + ret0, _ := ret[0].(*redis.XStreamSliceCmd) + return ret0 +} + +// XReadStreams indicates an expected call of XReadStreams. +func (mr *MockUniversalClientMockRecorder) XReadStreams(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockUniversalClient)(nil).XReadStreams), varargs...) +} + +// XRevRange mocks base method. +func (m *MockUniversalClient) XRevRange(arg0 context.Context, arg1, arg2, arg3 string) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRange indicates an expected call of XRevRange. +func (mr *MockUniversalClientMockRecorder) XRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockUniversalClient)(nil).XRevRange), arg0, arg1, arg2, arg3) +} + +// XRevRangeN mocks base method. +func (m *MockUniversalClient) XRevRangeN(arg0 context.Context, arg1, arg2, arg3 string, arg4 int64) *redis.XMessageSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XRevRangeN", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.XMessageSliceCmd) + return ret0 +} + +// XRevRangeN indicates an expected call of XRevRangeN. +func (mr *MockUniversalClientMockRecorder) XRevRangeN(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockUniversalClient)(nil).XRevRangeN), arg0, arg1, arg2, arg3, arg4) +} + +// XTrimMaxLen mocks base method. +func (m *MockUniversalClient) XTrimMaxLen(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLen", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLen indicates an expected call of XTrimMaxLen. +func (mr *MockUniversalClientMockRecorder) XTrimMaxLen(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLen), arg0, arg1, arg2) +} + +// XTrimMaxLenApprox mocks base method. +func (m *MockUniversalClient) XTrimMaxLenApprox(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMaxLenApprox", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox. +func (mr *MockUniversalClientMockRecorder) XTrimMaxLenApprox(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMaxLenApprox), arg0, arg1, arg2, arg3) +} + +// XTrimMinID mocks base method. +func (m *MockUniversalClient) XTrimMinID(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinID", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinID indicates an expected call of XTrimMinID. +func (mr *MockUniversalClientMockRecorder) XTrimMinID(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinID), arg0, arg1, arg2) +} + +// XTrimMinIDApprox mocks base method. +func (m *MockUniversalClient) XTrimMinIDApprox(arg0 context.Context, arg1, arg2 string, arg3 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "XTrimMinIDApprox", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox. +func (mr *MockUniversalClientMockRecorder) XTrimMinIDApprox(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockUniversalClient)(nil).XTrimMinIDApprox), arg0, arg1, arg2, arg3) +} + +// ZAdd mocks base method. +func (m *MockUniversalClient) ZAdd(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAdd", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAdd indicates an expected call of ZAdd. +func (mr *MockUniversalClientMockRecorder) ZAdd(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockUniversalClient)(nil).ZAdd), varargs...) +} + +// ZAddArgs mocks base method. +func (m *MockUniversalClient) ZAddArgs(arg0 context.Context, arg1 string, arg2 redis.ZAddArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgs", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddArgs indicates an expected call of ZAddArgs. +func (mr *MockUniversalClientMockRecorder) ZAddArgs(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockUniversalClient)(nil).ZAddArgs), arg0, arg1, arg2) +} + +// ZAddArgsIncr mocks base method. +func (m *MockUniversalClient) ZAddArgsIncr(arg0 context.Context, arg1 string, arg2 redis.ZAddArgs) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZAddArgsIncr", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZAddArgsIncr indicates an expected call of ZAddArgsIncr. +func (mr *MockUniversalClientMockRecorder) ZAddArgsIncr(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockUniversalClient)(nil).ZAddArgsIncr), arg0, arg1, arg2) +} + +// ZAddGT mocks base method. +func (m *MockUniversalClient) ZAddGT(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddGT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddGT indicates an expected call of ZAddGT. +func (mr *MockUniversalClientMockRecorder) ZAddGT(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddGT", reflect.TypeOf((*MockUniversalClient)(nil).ZAddGT), varargs...) +} + +// ZAddLT mocks base method. +func (m *MockUniversalClient) ZAddLT(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddLT", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddLT indicates an expected call of ZAddLT. +func (mr *MockUniversalClientMockRecorder) ZAddLT(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddLT", reflect.TypeOf((*MockUniversalClient)(nil).ZAddLT), varargs...) +} + +// ZAddNX mocks base method. +func (m *MockUniversalClient) ZAddNX(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddNX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddNX indicates an expected call of ZAddNX. +func (mr *MockUniversalClientMockRecorder) ZAddNX(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockUniversalClient)(nil).ZAddNX), varargs...) +} + +// ZAddXX mocks base method. +func (m *MockUniversalClient) ZAddXX(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZAddXX", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZAddXX indicates an expected call of ZAddXX. +func (mr *MockUniversalClientMockRecorder) ZAddXX(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockUniversalClient)(nil).ZAddXX), varargs...) +} + +// ZCard mocks base method. +func (m *MockUniversalClient) ZCard(arg0 context.Context, arg1 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCard", arg0, arg1) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCard indicates an expected call of ZCard. +func (mr *MockUniversalClientMockRecorder) ZCard(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockUniversalClient)(nil).ZCard), arg0, arg1) +} + +// ZCount mocks base method. +func (m *MockUniversalClient) ZCount(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZCount", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZCount indicates an expected call of ZCount. +func (mr *MockUniversalClientMockRecorder) ZCount(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockUniversalClient)(nil).ZCount), arg0, arg1, arg2, arg3) +} + +// ZDiff mocks base method. +func (m *MockUniversalClient) ZDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiff", varargs...) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZDiff indicates an expected call of ZDiff. +func (mr *MockUniversalClientMockRecorder) ZDiff(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockUniversalClient)(nil).ZDiff), varargs...) +} + +// ZDiffStore mocks base method. +func (m *MockUniversalClient) ZDiffStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffStore", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZDiffStore indicates an expected call of ZDiffStore. +func (mr *MockUniversalClientMockRecorder) ZDiffStore(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockUniversalClient)(nil).ZDiffStore), varargs...) +} + +// ZDiffWithScores mocks base method. +func (m *MockUniversalClient) ZDiffWithScores(arg0 context.Context, arg1 ...string) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0} + for _, a := range arg1 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZDiffWithScores", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZDiffWithScores indicates an expected call of ZDiffWithScores. +func (mr *MockUniversalClientMockRecorder) ZDiffWithScores(arg0 any, arg1 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0}, arg1...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZDiffWithScores), varargs...) +} + +// ZIncrBy mocks base method. +func (m *MockUniversalClient) ZIncrBy(arg0 context.Context, arg1 string, arg2 float64, arg3 string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZIncrBy", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZIncrBy indicates an expected call of ZIncrBy. +func (mr *MockUniversalClientMockRecorder) ZIncrBy(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockUniversalClient)(nil).ZIncrBy), arg0, arg1, arg2, arg3) +} + +// ZInter mocks base method. +func (m *MockUniversalClient) ZInter(arg0 context.Context, arg1 *redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInter", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZInter indicates an expected call of ZInter. +func (mr *MockUniversalClientMockRecorder) ZInter(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockUniversalClient)(nil).ZInter), arg0, arg1) +} + +// ZInterCard mocks base method. +func (m *MockUniversalClient) ZInterCard(arg0 context.Context, arg1 int64, arg2 ...string) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZInterCard", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterCard indicates an expected call of ZInterCard. +func (mr *MockUniversalClientMockRecorder) ZInterCard(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterCard", reflect.TypeOf((*MockUniversalClient)(nil).ZInterCard), varargs...) +} + +// ZInterStore mocks base method. +func (m *MockUniversalClient) ZInterStore(arg0 context.Context, arg1 string, arg2 *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterStore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZInterStore indicates an expected call of ZInterStore. +func (mr *MockUniversalClientMockRecorder) ZInterStore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockUniversalClient)(nil).ZInterStore), arg0, arg1, arg2) +} + +// ZInterWithScores mocks base method. +func (m *MockUniversalClient) ZInterWithScores(arg0 context.Context, arg1 *redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZInterWithScores", arg0, arg1) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZInterWithScores indicates an expected call of ZInterWithScores. +func (mr *MockUniversalClientMockRecorder) ZInterWithScores(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZInterWithScores), arg0, arg1) +} + +// ZLexCount mocks base method. +func (m *MockUniversalClient) ZLexCount(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZLexCount", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZLexCount indicates an expected call of ZLexCount. +func (mr *MockUniversalClientMockRecorder) ZLexCount(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockUniversalClient)(nil).ZLexCount), arg0, arg1, arg2, arg3) +} + +// ZMPop mocks base method. +func (m *MockUniversalClient) ZMPop(arg0 context.Context, arg1 string, arg2 int64, arg3 ...string) *redis.ZSliceWithKeyCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1, arg2} + for _, a := range arg3 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMPop", varargs...) + ret0, _ := ret[0].(*redis.ZSliceWithKeyCmd) + return ret0 +} + +// ZMPop indicates an expected call of ZMPop. +func (mr *MockUniversalClientMockRecorder) ZMPop(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1, arg2}, arg3...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMPop", reflect.TypeOf((*MockUniversalClient)(nil).ZMPop), varargs...) +} + +// ZMScore mocks base method. +func (m *MockUniversalClient) ZMScore(arg0 context.Context, arg1 string, arg2 ...string) *redis.FloatSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZMScore", varargs...) + ret0, _ := ret[0].(*redis.FloatSliceCmd) + return ret0 +} + +// ZMScore indicates an expected call of ZMScore. +func (mr *MockUniversalClientMockRecorder) ZMScore(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockUniversalClient)(nil).ZMScore), varargs...) +} + +// ZPopMax mocks base method. +func (m *MockUniversalClient) ZPopMax(arg0 context.Context, arg1 string, arg2 ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMax", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMax indicates an expected call of ZPopMax. +func (mr *MockUniversalClientMockRecorder) ZPopMax(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockUniversalClient)(nil).ZPopMax), varargs...) +} + +// ZPopMin mocks base method. +func (m *MockUniversalClient) ZPopMin(arg0 context.Context, arg1 string, arg2 ...int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZPopMin", varargs...) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZPopMin indicates an expected call of ZPopMin. +func (mr *MockUniversalClientMockRecorder) ZPopMin(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockUniversalClient)(nil).ZPopMin), varargs...) +} + +// ZRandMember mocks base method. +func (m *MockUniversalClient) ZRandMember(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMember", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRandMember indicates an expected call of ZRandMember. +func (mr *MockUniversalClientMockRecorder) ZRandMember(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockUniversalClient)(nil).ZRandMember), arg0, arg1, arg2) +} + +// ZRandMemberWithScores mocks base method. +func (m *MockUniversalClient) ZRandMemberWithScores(arg0 context.Context, arg1 string, arg2 int) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRandMemberWithScores", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores. +func (mr *MockUniversalClientMockRecorder) ZRandMemberWithScores(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRandMemberWithScores), arg0, arg1, arg2) +} + +// ZRange mocks base method. +func (m *MockUniversalClient) ZRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRange indicates an expected call of ZRange. +func (mr *MockUniversalClientMockRecorder) ZRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockUniversalClient)(nil).ZRange), arg0, arg1, arg2, arg3) +} + +// ZRangeArgs mocks base method. +func (m *MockUniversalClient) ZRangeArgs(arg0 context.Context, arg1 redis.ZRangeArgs) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgs", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeArgs indicates an expected call of ZRangeArgs. +func (mr *MockUniversalClientMockRecorder) ZRangeArgs(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeArgs), arg0, arg1) +} + +// ZRangeArgsWithScores mocks base method. +func (m *MockUniversalClient) ZRangeArgsWithScores(arg0 context.Context, arg1 redis.ZRangeArgs) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeArgsWithScores", arg0, arg1) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores. +func (mr *MockUniversalClientMockRecorder) ZRangeArgsWithScores(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeArgsWithScores), arg0, arg1) +} + +// ZRangeByLex mocks base method. +func (m *MockUniversalClient) ZRangeByLex(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByLex", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByLex indicates an expected call of ZRangeByLex. +func (mr *MockUniversalClientMockRecorder) ZRangeByLex(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByLex), arg0, arg1, arg2) +} + +// ZRangeByScore mocks base method. +func (m *MockUniversalClient) ZRangeByScore(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRangeByScore indicates an expected call of ZRangeByScore. +func (mr *MockUniversalClientMockRecorder) ZRangeByScore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByScore), arg0, arg1, arg2) +} + +// ZRangeByScoreWithScores mocks base method. +func (m *MockUniversalClient) ZRangeByScoreWithScores(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeByScoreWithScores", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores. +func (mr *MockUniversalClientMockRecorder) ZRangeByScoreWithScores(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeByScoreWithScores), arg0, arg1, arg2) +} + +// ZRangeStore mocks base method. +func (m *MockUniversalClient) ZRangeStore(arg0 context.Context, arg1 string, arg2 redis.ZRangeArgs) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeStore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRangeStore indicates an expected call of ZRangeStore. +func (mr *MockUniversalClientMockRecorder) ZRangeStore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeStore), arg0, arg1, arg2) +} + +// ZRangeWithScores mocks base method. +func (m *MockUniversalClient) ZRangeWithScores(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRangeWithScores", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRangeWithScores indicates an expected call of ZRangeWithScores. +func (mr *MockUniversalClientMockRecorder) ZRangeWithScores(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRangeWithScores), arg0, arg1, arg2, arg3) +} + +// ZRank mocks base method. +func (m *MockUniversalClient) ZRank(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRank", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRank indicates an expected call of ZRank. +func (mr *MockUniversalClientMockRecorder) ZRank(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRank), arg0, arg1, arg2) +} + +// ZRankWithScore mocks base method. +func (m *MockUniversalClient) ZRankWithScore(arg0 context.Context, arg1, arg2 string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRankWithScore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRankWithScore indicates an expected call of ZRankWithScore. +func (mr *MockUniversalClientMockRecorder) ZRankWithScore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRankWithScore), arg0, arg1, arg2) +} + +// ZRem mocks base method. +func (m *MockUniversalClient) ZRem(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd { + m.ctrl.T.Helper() + varargs := []any{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ZRem", varargs...) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRem indicates an expected call of ZRem. +func (mr *MockUniversalClientMockRecorder) ZRem(arg0, arg1 any, arg2 ...any) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]any{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockUniversalClient)(nil).ZRem), varargs...) +} + +// ZRemRangeByLex mocks base method. +func (m *MockUniversalClient) ZRemRangeByLex(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByLex", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByLex indicates an expected call of ZRemRangeByLex. +func (mr *MockUniversalClientMockRecorder) ZRemRangeByLex(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByLex), arg0, arg1, arg2, arg3) +} + +// ZRemRangeByRank mocks base method. +func (m *MockUniversalClient) ZRemRangeByRank(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByRank", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByRank indicates an expected call of ZRemRangeByRank. +func (mr *MockUniversalClientMockRecorder) ZRemRangeByRank(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByRank), arg0, arg1, arg2, arg3) +} + +// ZRemRangeByScore mocks base method. +func (m *MockUniversalClient) ZRemRangeByScore(arg0 context.Context, arg1, arg2, arg3 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRemRangeByScore", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRemRangeByScore indicates an expected call of ZRemRangeByScore. +func (mr *MockUniversalClientMockRecorder) ZRemRangeByScore(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRemRangeByScore), arg0, arg1, arg2, arg3) +} + +// ZRevRange mocks base method. +func (m *MockUniversalClient) ZRevRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRange", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRange indicates an expected call of ZRevRange. +func (mr *MockUniversalClientMockRecorder) ZRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRange), arg0, arg1, arg2, arg3) +} + +// ZRevRangeByLex mocks base method. +func (m *MockUniversalClient) ZRevRangeByLex(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByLex", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByLex indicates an expected call of ZRevRangeByLex. +func (mr *MockUniversalClientMockRecorder) ZRevRangeByLex(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByLex), arg0, arg1, arg2) +} + +// ZRevRangeByScore mocks base method. +func (m *MockUniversalClient) ZRevRangeByScore(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZRevRangeByScore indicates an expected call of ZRevRangeByScore. +func (mr *MockUniversalClientMockRecorder) ZRevRangeByScore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByScore), arg0, arg1, arg2) +} + +// ZRevRangeByScoreWithScores mocks base method. +func (m *MockUniversalClient) ZRevRangeByScoreWithScores(arg0 context.Context, arg1 string, arg2 *redis.ZRangeBy) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeByScoreWithScores", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores. +func (mr *MockUniversalClientMockRecorder) ZRevRangeByScoreWithScores(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeByScoreWithScores), arg0, arg1, arg2) +} + +// ZRevRangeWithScores mocks base method. +func (m *MockUniversalClient) ZRevRangeWithScores(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRangeWithScores", arg0, arg1, arg2, arg3) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores. +func (mr *MockUniversalClientMockRecorder) ZRevRangeWithScores(arg0, arg1, arg2, arg3 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRangeWithScores), arg0, arg1, arg2, arg3) +} + +// ZRevRank mocks base method. +func (m *MockUniversalClient) ZRevRank(arg0 context.Context, arg1, arg2 string) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRank", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZRevRank indicates an expected call of ZRevRank. +func (mr *MockUniversalClientMockRecorder) ZRevRank(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRank), arg0, arg1, arg2) +} + +// ZRevRankWithScore mocks base method. +func (m *MockUniversalClient) ZRevRankWithScore(arg0 context.Context, arg1, arg2 string) *redis.RankWithScoreCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZRevRankWithScore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.RankWithScoreCmd) + return ret0 +} + +// ZRevRankWithScore indicates an expected call of ZRevRankWithScore. +func (mr *MockUniversalClientMockRecorder) ZRevRankWithScore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockUniversalClient)(nil).ZRevRankWithScore), arg0, arg1, arg2) +} + +// ZScan mocks base method. +func (m *MockUniversalClient) ZScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScan", arg0, arg1, arg2, arg3, arg4) + ret0, _ := ret[0].(*redis.ScanCmd) + return ret0 +} + +// ZScan indicates an expected call of ZScan. +func (mr *MockUniversalClientMockRecorder) ZScan(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockUniversalClient)(nil).ZScan), arg0, arg1, arg2, arg3, arg4) +} + +// ZScore mocks base method. +func (m *MockUniversalClient) ZScore(arg0 context.Context, arg1, arg2 string) *redis.FloatCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZScore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.FloatCmd) + return ret0 +} + +// ZScore indicates an expected call of ZScore. +func (mr *MockUniversalClientMockRecorder) ZScore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockUniversalClient)(nil).ZScore), arg0, arg1, arg2) +} + +// ZUnion mocks base method. +func (m *MockUniversalClient) ZUnion(arg0 context.Context, arg1 redis.ZStore) *redis.StringSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnion", arg0, arg1) + ret0, _ := ret[0].(*redis.StringSliceCmd) + return ret0 +} + +// ZUnion indicates an expected call of ZUnion. +func (mr *MockUniversalClientMockRecorder) ZUnion(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockUniversalClient)(nil).ZUnion), arg0, arg1) +} + +// ZUnionStore mocks base method. +func (m *MockUniversalClient) ZUnionStore(arg0 context.Context, arg1 string, arg2 *redis.ZStore) *redis.IntCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionStore", arg0, arg1, arg2) + ret0, _ := ret[0].(*redis.IntCmd) + return ret0 +} + +// ZUnionStore indicates an expected call of ZUnionStore. +func (mr *MockUniversalClientMockRecorder) ZUnionStore(arg0, arg1, arg2 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockUniversalClient)(nil).ZUnionStore), arg0, arg1, arg2) +} + +// ZUnionWithScores mocks base method. +func (m *MockUniversalClient) ZUnionWithScores(arg0 context.Context, arg1 redis.ZStore) *redis.ZSliceCmd { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ZUnionWithScores", arg0, arg1) + ret0, _ := ret[0].(*redis.ZSliceCmd) + return ret0 +} + +// ZUnionWithScores indicates an expected call of ZUnionWithScores. +func (mr *MockUniversalClientMockRecorder) ZUnionWithScores(arg0, arg1 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockUniversalClient)(nil).ZUnionWithScores), arg0, arg1) +} diff --git a/modules/queue/workerqueue.go b/modules/queue/workerqueue.go index b28fd88027..041ce9a3f2 100644 --- a/modules/queue/workerqueue.go +++ b/modules/queue/workerqueue.go @@ -192,16 +192,24 @@ func (q *WorkerPoolQueue[T]) ShutdownWait(timeout time.Duration) { <-q.shutdownDone } -func getNewQueueFn(t string) (string, func(cfg *BaseConfig, unique bool) (baseQueue, error)) { +func getNewQueue(t string, cfg *BaseConfig, unique bool) (string, baseQueue, error) { switch t { case "dummy", "immediate": - return t, newBaseDummy + queue, err := newBaseDummy(cfg, unique) + + return t, queue, err case "channel": - return t, newBaseChannelGeneric + queue, err := newBaseChannelGeneric(cfg, unique) + + return t, queue, err case "redis": - return t, newBaseRedisGeneric + queue, err := newBaseRedisGeneric(cfg, unique, nil) + + return t, queue, err default: // level(leveldb,levelqueue,persistable-channel) - return "level", newBaseLevelQueueGeneric + queue, err := newBaseLevelQueueGeneric(cfg, unique) + + return "level", queue, err } } @@ -217,14 +225,14 @@ func NewWorkerPoolQueueWithContext[T any](ctx context.Context, name string, queu var w WorkerPoolQueue[T] var err error - queueType, newQueueFn := getNewQueueFn(queueSetting.Type) - w.baseQueueType = queueType + w.baseConfig = toBaseConfig(name, queueSetting) - w.baseQueue, err = newQueueFn(w.baseConfig, unique) + + w.baseQueueType, w.baseQueue, err = getNewQueue(queueSetting.Type, w.baseConfig, unique) if err != nil { return nil, err } - log.Trace("Created queue %q of type %q", name, queueType) + log.Trace("Created queue %q of type %q", name, w.baseQueueType) w.ctxRun, _, w.ctxRunCancel = process.GetManager().AddTypedContext(ctx, "Queue: "+w.GetName(), process.SystemProcessType, false) w.batchChan = make(chan []T)