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..1744d7393f 100644
--- a/go.mod
+++ b/go.mod
@@ -101,6 +101,7 @@ require (
 	github.com/yuin/goldmark v1.7.0
 	github.com/yuin/goldmark-highlighting/v2 v2.0.0-20230729083705-37449abec8cc
 	github.com/yuin/goldmark-meta v1.1.0
+	go.uber.org/mock v0.4.0
 	golang.org/x/crypto v0.23.0
 	golang.org/x/image v0.15.0
 	golang.org/x/net v0.25.0
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..b73404f4e5
--- /dev/null
+++ b/modules/queue/base_redis_with_server_test.go
@@ -0,0 +1,133 @@
+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)