diff --git a/.github/workflows/changelog.yml b/.github/workflows/changelog.yml
deleted file mode 100644
index 431f073..0000000
--- a/.github/workflows/changelog.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-# Copyright 2021 gotomicro
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-name: changelog
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened, labeled, unlabeled]
-    branches:
-      - develop
-      - main
-      - dev
-
-jobs:
-  changelog:
-    runs-on: ubuntu-latest
-    if: "!contains(github.event.pull_request.labels.*.name, 'Skip Changelog')"
-
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Check for CHANGELOG changes
-        run: |
-          # Only the latest commit of the feature branch is available
-          # automatically. To diff with the base branch, we need to
-          # fetch that too (and we only need its latest commit).
-          git fetch origin ${{ github.base_ref }} --depth=1
-          if [[ $(git diff --name-only FETCH_HEAD | grep CHANGELOG) ]]
-          then
-            echo "A CHANGELOG was modified. Looks good!"
-          else
-            echo "No CHANGELOG was modified."
-            echo "Please add a CHANGELOG entry, or add the \"Skip Changelog\" label if not required."
-            false
-          fi
\ No newline at end of file
diff --git a/Makefile b/Makefile
index 213913a..ae638a4 100644
--- a/Makefile
+++ b/Makefile
@@ -42,4 +42,4 @@ e2e_down:
 
 .PHONY: mock
 mock:
-	mockgen -copyright_file=.license.go.header -package=mocks -destination=mocks/redis_cmdable.mock.go github.com/go-redis/redis/v9 Cmdable
\ No newline at end of file
+	mockgen -copyright_file=.license.go.header -package=mocks -destination=mocks/redis_cmdable.mock.go github.com/redis/go-redis/v9 Cmdable
\ No newline at end of file
diff --git a/demo/demo.go b/demo/demo.go
index a21d1e9..beaba90 100644
--- a/demo/demo.go
+++ b/demo/demo.go
@@ -22,9 +22,8 @@ import (
 	"errors"
 	"time"
 
-	"github.com/go-redis/redis/v9"
-	"github.com/google/uuid"
 	rlock "github.com/gotomicro/redis-lock"
+	"github.com/redis/go-redis/v9"
 	"golang.org/x/sync/singleflight"
 )
 
diff --git a/demo/demo_e2e_test.go b/demo/demo_e2e_test.go
index e3c550d..115ba7d 100644
--- a/demo/demo_e2e_test.go
+++ b/demo/demo_e2e_test.go
@@ -21,7 +21,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/go-redis/redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/demo/demo_test.go b/demo/demo_test.go
index 27fabe9..91834c8 100644
--- a/demo/demo_test.go
+++ b/demo/demo_test.go
@@ -22,9 +22,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/go-redis/redis/v9"
-	"github.com/golang/mock/gomock"
 	"github.com/gotomicro/redis-lock/mocks"
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 )
 
diff --git a/go.mod b/go.mod
index 579301d..336aac0 100644
--- a/go.mod
+++ b/go.mod
@@ -3,17 +3,17 @@ module github.com/gotomicro/redis-lock
 go 1.18
 
 require (
-	github.com/go-redis/redis/v9 v9.0.0-beta.3
-	github.com/golang/mock v1.6.0
 	github.com/google/uuid v1.3.0
-	github.com/stretchr/testify v1.5.1
+	github.com/redis/go-redis/v9 v9.3.0
+	github.com/stretchr/testify v1.8.1
 	golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0
 )
 
 require (
-	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v2 v2.3.0 // indirect
+	go.uber.org/mock v0.3.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index d7fef31..7dfd99e 100644
--- a/go.sum
+++ b/go.sum
@@ -1,34 +1,36 @@
-github.com/cespare/xxhash/v2 v2.1.2 h1:YRXhKfTDauu4ajMg1TPgFO5jnlC2HCbmLXMcTG5cbYE=
-github.com/cespare/xxhash/v2 v2.1.2/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
-github.com/go-redis/redis/v9 v9.0.0-beta.3 h1:rkIfHaVFD8vPPfA44MTKFtRlQ6I7K3xvQwKOu+Qnh94=
-github.com/go-redis/redis/v9 v9.0.0-beta.3/go.mod h1:XNkosunJlFQUw/sKdZ9rMyoRFgqk9SLUv2gbKTtvWl8=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
 github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
-github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg=
 github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
 github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
-github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE=
-github.com/onsi/gomega v1.20.2 h1:8uQq0zMgLEfa0vRrrBgaJF2gyW9Da9BmfGV+OyUzfkY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/redis/go-redis/v9 v9.3.0 h1:RiVDjmig62jIWp7Kk4XVLs0hzV6pI3PyTnnL0cnn0u0=
+github.com/redis/go-redis/v9 v9.3.0/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/yuin/goldmark v1.3.5/go.mod h1:mwnBkeHKe2W/ZEtQ+71ViKU8L12m81fl3OWwC1Zlc8k=
+go.uber.org/mock v0.3.0 h1:3mUxI1No2/60yUYax92Pt8eNOEecx2D3lcXZh2NEZJo=
+go.uber.org/mock v0.3.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.0.0-20220722155237-a158d28d115b h1:PxfKdU9lEEDYjdIzOtC4qFWgkU2rGHdKlKowJSMN9h0=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0 h1:cu5kTvlzcw1Q5S9f5ip1/cpiB4nXvw1XYzFPGgzLUOY=
@@ -38,11 +40,9 @@ golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
@@ -51,8 +51,6 @@ golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
diff --git a/lock.go b/lock.go
index 59b6d54..43a8596 100644
--- a/lock.go
+++ b/lock.go
@@ -19,10 +19,10 @@ import (
 	_ "embed"
 	"errors"
 	"fmt"
+	"github.com/redis/go-redis/v9"
 	"sync"
 	"time"
 
-	"github.com/go-redis/redis/v9"
 	"github.com/google/uuid"
 	"golang.org/x/sync/singleflight"
 )
diff --git a/lock_e2e_test.go b/lock_e2e_test.go
index a0ac941..0e53ddc 100644
--- a/lock_e2e_test.go
+++ b/lock_e2e_test.go
@@ -22,7 +22,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/go-redis/redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/stretchr/testify/suite"
diff --git a/lock_test.go b/lock_test.go
index 5b631d0..7a5754d 100644
--- a/lock_test.go
+++ b/lock_test.go
@@ -18,12 +18,12 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"go.uber.org/mock/gomock"
 	"testing"
 	"time"
 
-	"github.com/go-redis/redis/v9"
-	"github.com/golang/mock/gomock"
 	"github.com/gotomicro/redis-lock/mocks"
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
diff --git a/mocks/redis_cmdable.mock.go b/mocks/redis_cmdable.mock.go
index 1a34e6d..9a06f84 100644
--- a/mocks/redis_cmdable.mock.go
+++ b/mocks/redis_cmdable.mock.go
@@ -13,8 +13,12 @@
 // limitations under the License.
 
 // Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/go-redis/redis/v9 (interfaces: Cmdable)
-
+// Source: github.com/redis/go-redis/v9 (interfaces: Cmdable)
+//
+// Generated by this command:
+//
+//	mockgen -copyright_file=.license.go.header -package=mocks -destination=mocks/redis_cmdable.mock.go github.com/redis/go-redis/v9 Cmdable
+//
 // Package mocks is a generated GoMock package.
 package mocks
 
@@ -23,8 +27,8 @@ import (
 	reflect "reflect"
 	time "time"
 
-	redis "github.com/go-redis/redis/v9"
-	gomock "github.com/golang/mock/gomock"
+	redis "github.com/redis/go-redis/v9"
+	gomock "go.uber.org/mock/gomock"
 )
 
 // MockCmdable is a mock of Cmdable interface.
@@ -50,6 +54,53 @@ func (m *MockCmdable) EXPECT() *MockCmdableMockRecorder {
 	return m.recorder
 }
 
+// ACLDryRun mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).ACLDryRun), varargs...)
+}
+
+// ACLLog mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ACLLog(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLog", reflect.TypeOf((*MockCmdable)(nil).ACLLog), arg0, arg1)
+}
+
+// ACLLogReset mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ACLLogReset(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ACLLogReset", reflect.TypeOf((*MockCmdable)(nil).ACLLogReset), arg0)
+}
+
 // Append mocks base method.
 func (m *MockCmdable) Append(arg0 context.Context, arg1, arg2 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
@@ -59,11 +110,311 @@ func (m *MockCmdable) Append(arg0 context.Context, arg1, arg2 string) *redis.Int
 }
 
 // Append indicates an expected call of Append.
-func (mr *MockCmdableMockRecorder) Append(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) Append(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Append", reflect.TypeOf((*MockCmdable)(nil).Append), arg0, arg1, arg2)
 }
 
+// BFAdd mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFAdd(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFAdd", reflect.TypeOf((*MockCmdable)(nil).BFAdd), arg0, arg1, arg2)
+}
+
+// BFCard mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFCard(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFCard", reflect.TypeOf((*MockCmdable)(nil).BFCard), arg0, arg1)
+}
+
+// BFExists mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFExists(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFExists", reflect.TypeOf((*MockCmdable)(nil).BFExists), arg0, arg1, arg2)
+}
+
+// BFInfo mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfo(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfo", reflect.TypeOf((*MockCmdable)(nil).BFInfo), arg0, arg1)
+}
+
+// BFInfoArg mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfoArg(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoArg", reflect.TypeOf((*MockCmdable)(nil).BFInfoArg), arg0, arg1, arg2)
+}
+
+// BFInfoCapacity mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfoCapacity(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoCapacity", reflect.TypeOf((*MockCmdable)(nil).BFInfoCapacity), arg0, arg1)
+}
+
+// BFInfoExpansion mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfoExpansion(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoExpansion", reflect.TypeOf((*MockCmdable)(nil).BFInfoExpansion), arg0, arg1)
+}
+
+// BFInfoFilters mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfoFilters(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoFilters", reflect.TypeOf((*MockCmdable)(nil).BFInfoFilters), arg0, arg1)
+}
+
+// BFInfoItems mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfoItems(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoItems", reflect.TypeOf((*MockCmdable)(nil).BFInfoItems), arg0, arg1)
+}
+
+// BFInfoSize mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFInfoSize(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFInfoSize", reflect.TypeOf((*MockCmdable)(nil).BFInfoSize), arg0, arg1)
+}
+
+// BFInsert mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).BFInsert), varargs...)
+}
+
+// BFLoadChunk mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFLoadChunk(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).BFLoadChunk), arg0, arg1, arg2, arg3)
+}
+
+// BFMAdd mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).BFMAdd), varargs...)
+}
+
+// BFMExists mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).BFMExists), varargs...)
+}
+
+// BFReserve mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFReserve(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserve", reflect.TypeOf((*MockCmdable)(nil).BFReserve), arg0, arg1, arg2, arg3)
+}
+
+// BFReserveExpansion mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFReserveExpansion(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).BFReserveExpansion), arg0, arg1, arg2, arg3, arg4)
+}
+
+// BFReserveNonScaling mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFReserveNonScaling(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveNonScaling", reflect.TypeOf((*MockCmdable)(nil).BFReserveNonScaling), arg0, arg1, arg2, arg3)
+}
+
+// BFReserveWithArgs mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFReserveWithArgs(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFReserveWithArgs", reflect.TypeOf((*MockCmdable)(nil).BFReserveWithArgs), arg0, arg1, arg2)
+}
+
+// BFScanDump mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) BFScanDump(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BFScanDump", reflect.TypeOf((*MockCmdable)(nil).BFScanDump), arg0, arg1, arg2)
+}
+
+// BLMPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).BLMPop), varargs...)
+}
+
 // BLMove mocks base method.
 func (m *MockCmdable) BLMove(arg0 context.Context, arg1, arg2, arg3, arg4 string, arg5 time.Duration) *redis.StringCmd {
 	m.ctrl.T.Helper()
@@ -73,7 +424,7 @@ func (m *MockCmdable) BLMove(arg0 context.Context, arg1, arg2, arg3, arg4 string
 }
 
 // BLMove indicates an expected call of BLMove.
-func (mr *MockCmdableMockRecorder) BLMove(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) 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((*MockCmdable)(nil).BLMove), arg0, arg1, arg2, arg3, arg4, arg5)
 }
@@ -81,7 +432,7 @@ func (mr *MockCmdableMockRecorder) BLMove(arg0, arg1, arg2, arg3, arg4, arg5 int
 // BLPop mocks base method.
 func (m *MockCmdable) BLPop(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -91,16 +442,16 @@ func (m *MockCmdable) BLPop(arg0 context.Context, arg1 time.Duration, arg2 ...st
 }
 
 // BLPop indicates an expected call of BLPop.
-func (mr *MockCmdableMockRecorder) BLPop(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BLPop(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BLPop", reflect.TypeOf((*MockCmdable)(nil).BLPop), varargs...)
 }
 
 // BRPop mocks base method.
 func (m *MockCmdable) BRPop(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -110,9 +461,9 @@ func (m *MockCmdable) BRPop(arg0 context.Context, arg1 time.Duration, arg2 ...st
 }
 
 // BRPop indicates an expected call of BRPop.
-func (mr *MockCmdableMockRecorder) BRPop(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BRPop(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPop", reflect.TypeOf((*MockCmdable)(nil).BRPop), varargs...)
 }
 
@@ -125,15 +476,34 @@ func (m *MockCmdable) BRPopLPush(arg0 context.Context, arg1, arg2 string, arg3 t
 }
 
 // BRPopLPush indicates an expected call of BRPopLPush.
-func (mr *MockCmdableMockRecorder) BRPopLPush(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BRPopLPush(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BRPopLPush", reflect.TypeOf((*MockCmdable)(nil).BRPopLPush), arg0, arg1, arg2, arg3)
 }
 
+// BZMPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).BZMPop), varargs...)
+}
+
 // BZPopMax mocks base method.
 func (m *MockCmdable) BZPopMax(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.ZWithKeyCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -143,16 +513,16 @@ func (m *MockCmdable) BZPopMax(arg0 context.Context, arg1 time.Duration, arg2 ..
 }
 
 // BZPopMax indicates an expected call of BZPopMax.
-func (mr *MockCmdableMockRecorder) BZPopMax(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BZPopMax(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMax", reflect.TypeOf((*MockCmdable)(nil).BZPopMax), varargs...)
 }
 
 // BZPopMin mocks base method.
 func (m *MockCmdable) BZPopMin(arg0 context.Context, arg1 time.Duration, arg2 ...string) *redis.ZWithKeyCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -162,9 +532,9 @@ func (m *MockCmdable) BZPopMin(arg0 context.Context, arg1 time.Duration, arg2 ..
 }
 
 // BZPopMin indicates an expected call of BZPopMin.
-func (mr *MockCmdableMockRecorder) BZPopMin(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BZPopMin(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BZPopMin", reflect.TypeOf((*MockCmdable)(nil).BZPopMin), varargs...)
 }
 
@@ -177,7 +547,7 @@ func (m *MockCmdable) BgRewriteAOF(arg0 context.Context) *redis.StatusCmd {
 }
 
 // BgRewriteAOF indicates an expected call of BgRewriteAOF.
-func (mr *MockCmdableMockRecorder) BgRewriteAOF(arg0 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BgRewriteAOF(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgRewriteAOF", reflect.TypeOf((*MockCmdable)(nil).BgRewriteAOF), arg0)
 }
@@ -191,7 +561,7 @@ func (m *MockCmdable) BgSave(arg0 context.Context) *redis.StatusCmd {
 }
 
 // BgSave indicates an expected call of BgSave.
-func (mr *MockCmdableMockRecorder) BgSave(arg0 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BgSave(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BgSave", reflect.TypeOf((*MockCmdable)(nil).BgSave), arg0)
 }
@@ -205,15 +575,15 @@ func (m *MockCmdable) BitCount(arg0 context.Context, arg1 string, arg2 *redis.Bi
 }
 
 // BitCount indicates an expected call of BitCount.
-func (mr *MockCmdableMockRecorder) BitCount(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitCount(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitCount", reflect.TypeOf((*MockCmdable)(nil).BitCount), arg0, arg1, arg2)
 }
 
 // BitField mocks base method.
-func (m *MockCmdable) BitField(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntSliceCmd {
+func (m *MockCmdable) BitField(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -223,16 +593,16 @@ func (m *MockCmdable) BitField(arg0 context.Context, arg1 string, arg2 ...interf
 }
 
 // BitField indicates an expected call of BitField.
-func (mr *MockCmdableMockRecorder) BitField(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitField(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitField", reflect.TypeOf((*MockCmdable)(nil).BitField), varargs...)
 }
 
 // BitOpAnd mocks base method.
 func (m *MockCmdable) BitOpAnd(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -242,9 +612,9 @@ func (m *MockCmdable) BitOpAnd(arg0 context.Context, arg1 string, arg2 ...string
 }
 
 // BitOpAnd indicates an expected call of BitOpAnd.
-func (mr *MockCmdableMockRecorder) BitOpAnd(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitOpAnd(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpAnd", reflect.TypeOf((*MockCmdable)(nil).BitOpAnd), varargs...)
 }
 
@@ -257,7 +627,7 @@ func (m *MockCmdable) BitOpNot(arg0 context.Context, arg1, arg2 string) *redis.I
 }
 
 // BitOpNot indicates an expected call of BitOpNot.
-func (mr *MockCmdableMockRecorder) BitOpNot(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitOpNot(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpNot", reflect.TypeOf((*MockCmdable)(nil).BitOpNot), arg0, arg1, arg2)
 }
@@ -265,7 +635,7 @@ func (mr *MockCmdableMockRecorder) BitOpNot(arg0, arg1, arg2 interface{}) *gomoc
 // BitOpOr mocks base method.
 func (m *MockCmdable) BitOpOr(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -275,16 +645,16 @@ func (m *MockCmdable) BitOpOr(arg0 context.Context, arg1 string, arg2 ...string)
 }
 
 // BitOpOr indicates an expected call of BitOpOr.
-func (mr *MockCmdableMockRecorder) BitOpOr(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitOpOr(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpOr", reflect.TypeOf((*MockCmdable)(nil).BitOpOr), varargs...)
 }
 
 // BitOpXor mocks base method.
 func (m *MockCmdable) BitOpXor(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -294,16 +664,16 @@ func (m *MockCmdable) BitOpXor(arg0 context.Context, arg1 string, arg2 ...string
 }
 
 // BitOpXor indicates an expected call of BitOpXor.
-func (mr *MockCmdableMockRecorder) BitOpXor(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitOpXor(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitOpXor", reflect.TypeOf((*MockCmdable)(nil).BitOpXor), varargs...)
 }
 
 // BitPos mocks base method.
 func (m *MockCmdable) BitPos(arg0 context.Context, arg1 string, arg2 int64, arg3 ...int64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
+	varargs := []any{arg0, arg1, arg2}
 	for _, a := range arg3 {
 		varargs = append(varargs, a)
 	}
@@ -313,2933 +683,5058 @@ func (m *MockCmdable) BitPos(arg0 context.Context, arg1 string, arg2 int64, arg3
 }
 
 // BitPos indicates an expected call of BitPos.
-func (mr *MockCmdableMockRecorder) BitPos(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) BitPos(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPos", reflect.TypeOf((*MockCmdable)(nil).BitPos), varargs...)
 }
 
-// ClientGetName mocks base method.
-func (m *MockCmdable) ClientGetName(arg0 context.Context) *redis.StringCmd {
+// BitPosSpan mocks base method.
+func (m *MockCmdable) BitPosSpan(arg0 context.Context, arg1 string, arg2 int8, arg3, arg4 int64, arg5 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientGetName", arg0)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "BitPosSpan", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// ClientGetName indicates an expected call of ClientGetName.
-func (mr *MockCmdableMockRecorder) ClientGetName(arg0 interface{}) *gomock.Call {
+// BitPosSpan indicates an expected call of BitPosSpan.
+func (mr *MockCmdableMockRecorder) BitPosSpan(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockCmdable)(nil).ClientGetName), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BitPosSpan", reflect.TypeOf((*MockCmdable)(nil).BitPosSpan), arg0, arg1, arg2, arg3, arg4, arg5)
 }
 
-// ClientID mocks base method.
-func (m *MockCmdable) ClientID(arg0 context.Context) *redis.IntCmd {
+// CFAdd mocks base method.
+func (m *MockCmdable) CFAdd(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientID", arg0)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "CFAdd", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// ClientID indicates an expected call of ClientID.
-func (mr *MockCmdableMockRecorder) ClientID(arg0 interface{}) *gomock.Call {
+// CFAdd indicates an expected call of CFAdd.
+func (mr *MockCmdableMockRecorder) CFAdd(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockCmdable)(nil).ClientID), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAdd", reflect.TypeOf((*MockCmdable)(nil).CFAdd), arg0, arg1, arg2)
 }
 
-// ClientKill mocks base method.
-func (m *MockCmdable) ClientKill(arg0 context.Context, arg1 string) *redis.StatusCmd {
+// CFAddNX mocks base method.
+func (m *MockCmdable) CFAddNX(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientKill", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "CFAddNX", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// ClientKill indicates an expected call of ClientKill.
-func (mr *MockCmdableMockRecorder) ClientKill(arg0, arg1 interface{}) *gomock.Call {
+// CFAddNX indicates an expected call of CFAddNX.
+func (mr *MockCmdableMockRecorder) CFAddNX(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockCmdable)(nil).ClientKill), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFAddNX", reflect.TypeOf((*MockCmdable)(nil).CFAddNX), arg0, arg1, arg2)
 }
 
-// ClientKillByFilter mocks base method.
-func (m *MockCmdable) ClientKillByFilter(arg0 context.Context, arg1 ...string) *redis.IntCmd {
+// CFCount mocks base method.
+func (m *MockCmdable) CFCount(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ClientKillByFilter", varargs...)
+	ret := m.ctrl.Call(m, "CFCount", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// ClientKillByFilter indicates an expected call of ClientKillByFilter.
-func (mr *MockCmdableMockRecorder) ClientKillByFilter(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// CFCount indicates an expected call of CFCount.
+func (mr *MockCmdableMockRecorder) CFCount(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockCmdable)(nil).ClientKillByFilter), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFCount", reflect.TypeOf((*MockCmdable)(nil).CFCount), arg0, arg1, arg2)
 }
 
-// ClientList mocks base method.
-func (m *MockCmdable) ClientList(arg0 context.Context) *redis.StringCmd {
+// CFDel mocks base method.
+func (m *MockCmdable) CFDel(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientList", arg0)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "CFDel", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// ClientList indicates an expected call of ClientList.
-func (mr *MockCmdableMockRecorder) ClientList(arg0 interface{}) *gomock.Call {
+// CFDel indicates an expected call of CFDel.
+func (mr *MockCmdableMockRecorder) CFDel(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockCmdable)(nil).ClientList), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFDel", reflect.TypeOf((*MockCmdable)(nil).CFDel), arg0, arg1, arg2)
 }
 
-// ClientPause mocks base method.
-func (m *MockCmdable) ClientPause(arg0 context.Context, arg1 time.Duration) *redis.BoolCmd {
+// CFExists mocks base method.
+func (m *MockCmdable) CFExists(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientPause", arg0, arg1)
+	ret := m.ctrl.Call(m, "CFExists", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// ClientPause indicates an expected call of ClientPause.
-func (mr *MockCmdableMockRecorder) ClientPause(arg0, arg1 interface{}) *gomock.Call {
+// CFExists indicates an expected call of CFExists.
+func (mr *MockCmdableMockRecorder) CFExists(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockCmdable)(nil).ClientPause), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFExists", reflect.TypeOf((*MockCmdable)(nil).CFExists), arg0, arg1, arg2)
 }
 
-// ClientUnblock mocks base method.
-func (m *MockCmdable) ClientUnblock(arg0 context.Context, arg1 int64) *redis.IntCmd {
+// CFInfo mocks base method.
+func (m *MockCmdable) CFInfo(arg0 context.Context, arg1 string) *redis.CFInfoCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientUnblock", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "CFInfo", arg0, arg1)
+	ret0, _ := ret[0].(*redis.CFInfoCmd)
 	return ret0
 }
 
-// ClientUnblock indicates an expected call of ClientUnblock.
-func (mr *MockCmdableMockRecorder) ClientUnblock(arg0, arg1 interface{}) *gomock.Call {
+// CFInfo indicates an expected call of CFInfo.
+func (mr *MockCmdableMockRecorder) CFInfo(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockCmdable)(nil).ClientUnblock), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInfo", reflect.TypeOf((*MockCmdable)(nil).CFInfo), arg0, arg1)
 }
 
-// ClientUnblockWithError mocks base method.
-func (m *MockCmdable) ClientUnblockWithError(arg0 context.Context, arg1 int64) *redis.IntCmd {
+// CFInsert mocks base method.
+func (m *MockCmdable) CFInsert(arg0 context.Context, arg1 string, arg2 *redis.CFInsertOptions, arg3 ...any) *redis.BoolSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClientUnblockWithError", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	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
 }
 
-// ClientUnblockWithError indicates an expected call of ClientUnblockWithError.
-func (mr *MockCmdableMockRecorder) ClientUnblockWithError(arg0, arg1 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockCmdable)(nil).ClientUnblockWithError), arg0, arg1)
-}
-
-// ClientUnpause mocks base method.
-func (m *MockCmdable) 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 *MockCmdableMockRecorder) ClientUnpause(arg0 interface{}) *gomock.Call {
+// CFInsert indicates an expected call of CFInsert.
+func (mr *MockCmdableMockRecorder) CFInsert(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockCmdable)(nil).ClientUnpause), arg0)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsert", reflect.TypeOf((*MockCmdable)(nil).CFInsert), varargs...)
 }
 
-// ClusterAddSlots mocks base method.
-func (m *MockCmdable) ClusterAddSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd {
+// CFInsertNX mocks base method.
+func (m *MockCmdable) CFInsertNX(arg0 context.Context, arg1 string, arg2 *redis.CFInsertOptions, arg3 ...any) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
+	varargs := []any{arg0, arg1, arg2}
+	for _, a := range arg3 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "ClusterAddSlots", varargs...)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "CFInsertNX", varargs...)
+	ret0, _ := ret[0].(*redis.IntSliceCmd)
 	return ret0
 }
 
-// ClusterAddSlots indicates an expected call of ClusterAddSlots.
-func (mr *MockCmdableMockRecorder) ClusterAddSlots(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// CFInsertNX indicates an expected call of CFInsertNX.
+func (mr *MockCmdableMockRecorder) CFInsertNX(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlots), varargs...)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFInsertNX", reflect.TypeOf((*MockCmdable)(nil).CFInsertNX), varargs...)
 }
 
-// ClusterAddSlotsRange mocks base method.
-func (m *MockCmdable) ClusterAddSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd {
+// CFLoadChunk mocks base method.
+func (m *MockCmdable) CFLoadChunk(arg0 context.Context, arg1 string, arg2 int64, arg3 any) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterAddSlotsRange", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "CFLoadChunk", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange.
-func (mr *MockCmdableMockRecorder) ClusterAddSlotsRange(arg0, arg1, arg2 interface{}) *gomock.Call {
+// CFLoadChunk indicates an expected call of CFLoadChunk.
+func (mr *MockCmdableMockRecorder) CFLoadChunk(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlotsRange), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFLoadChunk", reflect.TypeOf((*MockCmdable)(nil).CFLoadChunk), arg0, arg1, arg2, arg3)
 }
 
-// ClusterCountFailureReports mocks base method.
-func (m *MockCmdable) ClusterCountFailureReports(arg0 context.Context, arg1 string) *redis.IntCmd {
+// CFMExists mocks base method.
+func (m *MockCmdable) CFMExists(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterCountFailureReports", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	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
 }
 
-// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports.
-func (mr *MockCmdableMockRecorder) ClusterCountFailureReports(arg0, arg1 interface{}) *gomock.Call {
+// CFMExists indicates an expected call of CFMExists.
+func (mr *MockCmdableMockRecorder) CFMExists(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockCmdable)(nil).ClusterCountFailureReports), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFMExists", reflect.TypeOf((*MockCmdable)(nil).CFMExists), varargs...)
 }
 
-// ClusterCountKeysInSlot mocks base method.
-func (m *MockCmdable) ClusterCountKeysInSlot(arg0 context.Context, arg1 int) *redis.IntCmd {
+// CFReserve mocks base method.
+func (m *MockCmdable) CFReserve(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "CFReserve", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot.
-func (mr *MockCmdableMockRecorder) ClusterCountKeysInSlot(arg0, arg1 interface{}) *gomock.Call {
+// CFReserve indicates an expected call of CFReserve.
+func (mr *MockCmdableMockRecorder) CFReserve(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterCountKeysInSlot), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserve", reflect.TypeOf((*MockCmdable)(nil).CFReserve), arg0, arg1, arg2)
 }
 
-// ClusterDelSlots mocks base method.
-func (m *MockCmdable) ClusterDelSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd {
+// CFReserveBucketSize mocks base method.
+func (m *MockCmdable) CFReserveBucketSize(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ClusterDelSlots", varargs...)
+	ret := m.ctrl.Call(m, "CFReserveBucketSize", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterDelSlots indicates an expected call of ClusterDelSlots.
-func (mr *MockCmdableMockRecorder) ClusterDelSlots(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// CFReserveBucketSize indicates an expected call of CFReserveBucketSize.
+func (mr *MockCmdableMockRecorder) CFReserveBucketSize(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlots), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveBucketSize", reflect.TypeOf((*MockCmdable)(nil).CFReserveBucketSize), arg0, arg1, arg2, arg3)
 }
 
-// ClusterDelSlotsRange mocks base method.
-func (m *MockCmdable) ClusterDelSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd {
+// CFReserveExpansion mocks base method.
+func (m *MockCmdable) CFReserveExpansion(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterDelSlotsRange", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "CFReserveExpansion", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange.
-func (mr *MockCmdableMockRecorder) ClusterDelSlotsRange(arg0, arg1, arg2 interface{}) *gomock.Call {
+// CFReserveExpansion indicates an expected call of CFReserveExpansion.
+func (mr *MockCmdableMockRecorder) CFReserveExpansion(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlotsRange), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveExpansion", reflect.TypeOf((*MockCmdable)(nil).CFReserveExpansion), arg0, arg1, arg2, arg3)
 }
 
-// ClusterFailover mocks base method.
-func (m *MockCmdable) ClusterFailover(arg0 context.Context) *redis.StatusCmd {
+// CFReserveMaxIterations mocks base method.
+func (m *MockCmdable) CFReserveMaxIterations(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterFailover", arg0)
+	ret := m.ctrl.Call(m, "CFReserveMaxIterations", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterFailover indicates an expected call of ClusterFailover.
-func (mr *MockCmdableMockRecorder) ClusterFailover(arg0 interface{}) *gomock.Call {
+// CFReserveMaxIterations indicates an expected call of CFReserveMaxIterations.
+func (mr *MockCmdableMockRecorder) CFReserveMaxIterations(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockCmdable)(nil).ClusterFailover), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveMaxIterations", reflect.TypeOf((*MockCmdable)(nil).CFReserveMaxIterations), arg0, arg1, arg2, arg3)
 }
 
-// ClusterForget mocks base method.
-func (m *MockCmdable) ClusterForget(arg0 context.Context, arg1 string) *redis.StatusCmd {
+// CFReserveWithArgs mocks base method.
+func (m *MockCmdable) CFReserveWithArgs(arg0 context.Context, arg1 string, arg2 *redis.CFReserveOptions) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterForget", arg0, arg1)
+	ret := m.ctrl.Call(m, "CFReserveWithArgs", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterForget indicates an expected call of ClusterForget.
-func (mr *MockCmdableMockRecorder) ClusterForget(arg0, arg1 interface{}) *gomock.Call {
+// CFReserveWithArgs indicates an expected call of CFReserveWithArgs.
+func (mr *MockCmdableMockRecorder) CFReserveWithArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockCmdable)(nil).ClusterForget), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFReserveWithArgs", reflect.TypeOf((*MockCmdable)(nil).CFReserveWithArgs), arg0, arg1, arg2)
 }
 
-// ClusterGetKeysInSlot mocks base method.
-func (m *MockCmdable) ClusterGetKeysInSlot(arg0 context.Context, arg1, arg2 int) *redis.StringSliceCmd {
+// CFScanDump mocks base method.
+func (m *MockCmdable) CFScanDump(arg0 context.Context, arg1 string, arg2 int64) *redis.ScanDumpCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "CFScanDump", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.ScanDumpCmd)
 	return ret0
 }
 
-// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot.
-func (mr *MockCmdableMockRecorder) ClusterGetKeysInSlot(arg0, arg1, arg2 interface{}) *gomock.Call {
+// CFScanDump indicates an expected call of CFScanDump.
+func (mr *MockCmdableMockRecorder) CFScanDump(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterGetKeysInSlot), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CFScanDump", reflect.TypeOf((*MockCmdable)(nil).CFScanDump), arg0, arg1, arg2)
 }
 
-// ClusterInfo mocks base method.
-func (m *MockCmdable) ClusterInfo(arg0 context.Context) *redis.StringCmd {
+// CMSIncrBy mocks base method.
+func (m *MockCmdable) CMSIncrBy(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterInfo", arg0)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// ClusterInfo indicates an expected call of ClusterInfo.
-func (mr *MockCmdableMockRecorder) ClusterInfo(arg0 interface{}) *gomock.Call {
+// CMSIncrBy indicates an expected call of CMSIncrBy.
+func (mr *MockCmdableMockRecorder) CMSIncrBy(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockCmdable)(nil).ClusterInfo), arg0)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSIncrBy", reflect.TypeOf((*MockCmdable)(nil).CMSIncrBy), varargs...)
 }
 
-// ClusterKeySlot mocks base method.
-func (m *MockCmdable) ClusterKeySlot(arg0 context.Context, arg1 string) *redis.IntCmd {
+// CMSInfo mocks base method.
+func (m *MockCmdable) CMSInfo(arg0 context.Context, arg1 string) *redis.CMSInfoCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterKeySlot", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "CMSInfo", arg0, arg1)
+	ret0, _ := ret[0].(*redis.CMSInfoCmd)
 	return ret0
 }
 
-// ClusterKeySlot indicates an expected call of ClusterKeySlot.
-func (mr *MockCmdableMockRecorder) ClusterKeySlot(arg0, arg1 interface{}) *gomock.Call {
+// CMSInfo indicates an expected call of CMSInfo.
+func (mr *MockCmdableMockRecorder) CMSInfo(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockCmdable)(nil).ClusterKeySlot), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInfo", reflect.TypeOf((*MockCmdable)(nil).CMSInfo), arg0, arg1)
 }
 
-// ClusterMeet mocks base method.
-func (m *MockCmdable) ClusterMeet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
+// CMSInitByDim mocks base method.
+func (m *MockCmdable) CMSInitByDim(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterMeet", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "CMSInitByDim", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterMeet indicates an expected call of ClusterMeet.
-func (mr *MockCmdableMockRecorder) ClusterMeet(arg0, arg1, arg2 interface{}) *gomock.Call {
+// CMSInitByDim indicates an expected call of CMSInitByDim.
+func (mr *MockCmdableMockRecorder) CMSInitByDim(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockCmdable)(nil).ClusterMeet), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByDim", reflect.TypeOf((*MockCmdable)(nil).CMSInitByDim), arg0, arg1, arg2, arg3)
 }
 
-// ClusterNodes mocks base method.
-func (m *MockCmdable) ClusterNodes(arg0 context.Context) *redis.StringCmd {
+// CMSInitByProb mocks base method.
+func (m *MockCmdable) CMSInitByProb(arg0 context.Context, arg1 string, arg2, arg3 float64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterNodes", arg0)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "CMSInitByProb", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterNodes indicates an expected call of ClusterNodes.
-func (mr *MockCmdableMockRecorder) ClusterNodes(arg0 interface{}) *gomock.Call {
+// CMSInitByProb indicates an expected call of CMSInitByProb.
+func (mr *MockCmdableMockRecorder) CMSInitByProb(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockCmdable)(nil).ClusterNodes), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSInitByProb", reflect.TypeOf((*MockCmdable)(nil).CMSInitByProb), arg0, arg1, arg2, arg3)
 }
 
-// ClusterReplicate mocks base method.
-func (m *MockCmdable) ClusterReplicate(arg0 context.Context, arg1 string) *redis.StatusCmd {
+// CMSMerge mocks base method.
+func (m *MockCmdable) CMSMerge(arg0 context.Context, arg1 string, arg2 ...string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterReplicate", arg0, arg1)
+	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
 }
 
-// ClusterReplicate indicates an expected call of ClusterReplicate.
-func (mr *MockCmdableMockRecorder) ClusterReplicate(arg0, arg1 interface{}) *gomock.Call {
+// CMSMerge indicates an expected call of CMSMerge.
+func (mr *MockCmdableMockRecorder) CMSMerge(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockCmdable)(nil).ClusterReplicate), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMerge", reflect.TypeOf((*MockCmdable)(nil).CMSMerge), varargs...)
 }
 
-// ClusterResetHard mocks base method.
-func (m *MockCmdable) ClusterResetHard(arg0 context.Context) *redis.StatusCmd {
+// CMSMergeWithWeight mocks base method.
+func (m *MockCmdable) CMSMergeWithWeight(arg0 context.Context, arg1 string, arg2 map[string]int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterResetHard", arg0)
+	ret := m.ctrl.Call(m, "CMSMergeWithWeight", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ClusterResetHard indicates an expected call of ClusterResetHard.
-func (mr *MockCmdableMockRecorder) ClusterResetHard(arg0 interface{}) *gomock.Call {
+// CMSMergeWithWeight indicates an expected call of CMSMergeWithWeight.
+func (mr *MockCmdableMockRecorder) CMSMergeWithWeight(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockCmdable)(nil).ClusterResetHard), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSMergeWithWeight", reflect.TypeOf((*MockCmdable)(nil).CMSMergeWithWeight), arg0, arg1, arg2)
 }
 
-// ClusterResetSoft mocks base method.
-func (m *MockCmdable) ClusterResetSoft(arg0 context.Context) *redis.StatusCmd {
+// CMSQuery mocks base method.
+func (m *MockCmdable) CMSQuery(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterResetSoft", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	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
 }
 
-// ClusterResetSoft indicates an expected call of ClusterResetSoft.
-func (mr *MockCmdableMockRecorder) ClusterResetSoft(arg0 interface{}) *gomock.Call {
+// CMSQuery indicates an expected call of CMSQuery.
+func (mr *MockCmdableMockRecorder) CMSQuery(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockCmdable)(nil).ClusterResetSoft), arg0)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CMSQuery", reflect.TypeOf((*MockCmdable)(nil).CMSQuery), varargs...)
 }
 
-// ClusterSaveConfig mocks base method.
-func (m *MockCmdable) ClusterSaveConfig(arg0 context.Context) *redis.StatusCmd {
+// ClientGetName mocks base method.
+func (m *MockCmdable) ClientGetName(arg0 context.Context) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterSaveConfig", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "ClientGetName", arg0)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// ClusterSaveConfig indicates an expected call of ClusterSaveConfig.
-func (mr *MockCmdableMockRecorder) ClusterSaveConfig(arg0 interface{}) *gomock.Call {
+// ClientGetName indicates an expected call of ClientGetName.
+func (mr *MockCmdableMockRecorder) ClientGetName(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockCmdable)(nil).ClusterSaveConfig), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientGetName", reflect.TypeOf((*MockCmdable)(nil).ClientGetName), arg0)
 }
 
-// ClusterSlaves mocks base method.
-func (m *MockCmdable) ClusterSlaves(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// ClientID mocks base method.
+func (m *MockCmdable) ClientID(arg0 context.Context) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterSlaves", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "ClientID", arg0)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// ClusterSlaves indicates an expected call of ClusterSlaves.
-func (mr *MockCmdableMockRecorder) ClusterSlaves(arg0, arg1 interface{}) *gomock.Call {
+// ClientID indicates an expected call of ClientID.
+func (mr *MockCmdableMockRecorder) ClientID(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockCmdable)(nil).ClusterSlaves), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientID", reflect.TypeOf((*MockCmdable)(nil).ClientID), arg0)
 }
 
-// ClusterSlots mocks base method.
-func (m *MockCmdable) ClusterSlots(arg0 context.Context) *redis.ClusterSlotsCmd {
+// ClientInfo mocks base method.
+func (m *MockCmdable) ClientInfo(arg0 context.Context) *redis.ClientInfoCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ClusterSlots", arg0)
-	ret0, _ := ret[0].(*redis.ClusterSlotsCmd)
+	ret := m.ctrl.Call(m, "ClientInfo", arg0)
+	ret0, _ := ret[0].(*redis.ClientInfoCmd)
 	return ret0
 }
 
-// ClusterSlots indicates an expected call of ClusterSlots.
-func (mr *MockCmdableMockRecorder) ClusterSlots(arg0 interface{}) *gomock.Call {
+// ClientInfo indicates an expected call of ClientInfo.
+func (mr *MockCmdableMockRecorder) ClientInfo(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterSlots), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientInfo", reflect.TypeOf((*MockCmdable)(nil).ClientInfo), arg0)
 }
 
-// Command mocks base method.
-func (m *MockCmdable) Command(arg0 context.Context) *redis.CommandsInfoCmd {
+// ClientKill mocks base method.
+func (m *MockCmdable) ClientKill(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Command", arg0)
-	ret0, _ := ret[0].(*redis.CommandsInfoCmd)
+	ret := m.ctrl.Call(m, "ClientKill", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Command indicates an expected call of Command.
-func (mr *MockCmdableMockRecorder) Command(arg0 interface{}) *gomock.Call {
+// ClientKill indicates an expected call of ClientKill.
+func (mr *MockCmdableMockRecorder) ClientKill(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockCmdable)(nil).Command), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKill", reflect.TypeOf((*MockCmdable)(nil).ClientKill), arg0, arg1)
 }
 
-// ConfigGet mocks base method.
-func (m *MockCmdable) ConfigGet(arg0 context.Context, arg1 string) *redis.MapStringStringCmd {
+// ClientKillByFilter mocks base method.
+func (m *MockCmdable) ClientKillByFilter(arg0 context.Context, arg1 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfigGet", arg0, arg1)
-	ret0, _ := ret[0].(*redis.MapStringStringCmd)
+	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
 }
 
-// ConfigGet indicates an expected call of ConfigGet.
-func (mr *MockCmdableMockRecorder) ConfigGet(arg0, arg1 interface{}) *gomock.Call {
+// ClientKillByFilter indicates an expected call of ClientKillByFilter.
+func (mr *MockCmdableMockRecorder) ClientKillByFilter(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockCmdable)(nil).ConfigGet), arg0, arg1)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientKillByFilter", reflect.TypeOf((*MockCmdable)(nil).ClientKillByFilter), varargs...)
 }
 
-// ConfigResetStat mocks base method.
-func (m *MockCmdable) ConfigResetStat(arg0 context.Context) *redis.StatusCmd {
+// ClientList mocks base method.
+func (m *MockCmdable) ClientList(arg0 context.Context) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfigResetStat", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "ClientList", arg0)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// ConfigResetStat indicates an expected call of ConfigResetStat.
-func (mr *MockCmdableMockRecorder) ConfigResetStat(arg0 interface{}) *gomock.Call {
+// ClientList indicates an expected call of ClientList.
+func (mr *MockCmdableMockRecorder) ClientList(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockCmdable)(nil).ConfigResetStat), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientList", reflect.TypeOf((*MockCmdable)(nil).ClientList), arg0)
 }
 
-// ConfigRewrite mocks base method.
-func (m *MockCmdable) ConfigRewrite(arg0 context.Context) *redis.StatusCmd {
+// ClientPause mocks base method.
+func (m *MockCmdable) ClientPause(arg0 context.Context, arg1 time.Duration) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfigRewrite", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "ClientPause", arg0, arg1)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// ConfigRewrite indicates an expected call of ConfigRewrite.
-func (mr *MockCmdableMockRecorder) ConfigRewrite(arg0 interface{}) *gomock.Call {
+// ClientPause indicates an expected call of ClientPause.
+func (mr *MockCmdableMockRecorder) ClientPause(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockCmdable)(nil).ConfigRewrite), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientPause", reflect.TypeOf((*MockCmdable)(nil).ClientPause), arg0, arg1)
 }
 
-// ConfigSet mocks base method.
-func (m *MockCmdable) ConfigSet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
+// ClientUnblock mocks base method.
+func (m *MockCmdable) ClientUnblock(arg0 context.Context, arg1 int64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ConfigSet", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "ClientUnblock", arg0, arg1)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// ConfigSet indicates an expected call of ConfigSet.
-func (mr *MockCmdableMockRecorder) ConfigSet(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClientUnblock indicates an expected call of ClientUnblock.
+func (mr *MockCmdableMockRecorder) ClientUnblock(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockCmdable)(nil).ConfigSet), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblock", reflect.TypeOf((*MockCmdable)(nil).ClientUnblock), arg0, arg1)
 }
 
-// Copy mocks base method.
-func (m *MockCmdable) Copy(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 bool) *redis.IntCmd {
+// ClientUnblockWithError mocks base method.
+func (m *MockCmdable) ClientUnblockWithError(arg0 context.Context, arg1 int64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Copy", arg0, arg1, arg2, arg3, arg4)
+	ret := m.ctrl.Call(m, "ClientUnblockWithError", arg0, arg1)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// Copy indicates an expected call of Copy.
-func (mr *MockCmdableMockRecorder) Copy(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// ClientUnblockWithError indicates an expected call of ClientUnblockWithError.
+func (mr *MockCmdableMockRecorder) ClientUnblockWithError(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockCmdable)(nil).Copy), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnblockWithError", reflect.TypeOf((*MockCmdable)(nil).ClientUnblockWithError), arg0, arg1)
 }
 
-// DBSize mocks base method.
-func (m *MockCmdable) DBSize(arg0 context.Context) *redis.IntCmd {
+// ClientUnpause mocks base method.
+func (m *MockCmdable) ClientUnpause(arg0 context.Context) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DBSize", arg0)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ClientUnpause", arg0)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// DBSize indicates an expected call of DBSize.
-func (mr *MockCmdableMockRecorder) DBSize(arg0 interface{}) *gomock.Call {
+// ClientUnpause indicates an expected call of ClientUnpause.
+func (mr *MockCmdableMockRecorder) ClientUnpause(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockCmdable)(nil).DBSize), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClientUnpause", reflect.TypeOf((*MockCmdable)(nil).ClientUnpause), arg0)
 }
 
-// DebugObject mocks base method.
-func (m *MockCmdable) DebugObject(arg0 context.Context, arg1 string) *redis.StringCmd {
+// ClusterAddSlots mocks base method.
+func (m *MockCmdable) ClusterAddSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DebugObject", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// DebugObject indicates an expected call of DebugObject.
-func (mr *MockCmdableMockRecorder) DebugObject(arg0, arg1 interface{}) *gomock.Call {
+// ClusterAddSlots indicates an expected call of ClusterAddSlots.
+func (mr *MockCmdableMockRecorder) ClusterAddSlots(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockCmdable)(nil).DebugObject), arg0, arg1)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlots), varargs...)
 }
 
-// Decr mocks base method.
-func (m *MockCmdable) Decr(arg0 context.Context, arg1 string) *redis.IntCmd {
+// ClusterAddSlotsRange mocks base method.
+func (m *MockCmdable) ClusterAddSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Decr", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ClusterAddSlotsRange", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Decr indicates an expected call of Decr.
-func (mr *MockCmdableMockRecorder) Decr(arg0, arg1 interface{}) *gomock.Call {
+// ClusterAddSlotsRange indicates an expected call of ClusterAddSlotsRange.
+func (mr *MockCmdableMockRecorder) ClusterAddSlotsRange(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockCmdable)(nil).Decr), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterAddSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterAddSlotsRange), arg0, arg1, arg2)
 }
 
-// DecrBy mocks base method.
-func (m *MockCmdable) DecrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd {
+// ClusterCountFailureReports mocks base method.
+func (m *MockCmdable) ClusterCountFailureReports(arg0 context.Context, arg1 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "DecrBy", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "ClusterCountFailureReports", arg0, arg1)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// DecrBy indicates an expected call of DecrBy.
-func (mr *MockCmdableMockRecorder) DecrBy(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterCountFailureReports indicates an expected call of ClusterCountFailureReports.
+func (mr *MockCmdableMockRecorder) ClusterCountFailureReports(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockCmdable)(nil).DecrBy), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountFailureReports", reflect.TypeOf((*MockCmdable)(nil).ClusterCountFailureReports), arg0, arg1)
 }
 
-// Del mocks base method.
-func (m *MockCmdable) Del(arg0 context.Context, arg1 ...string) *redis.IntCmd {
+// ClusterCountKeysInSlot mocks base method.
+func (m *MockCmdable) ClusterCountKeysInSlot(arg0 context.Context, arg1 int) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "Del", varargs...)
+	ret := m.ctrl.Call(m, "ClusterCountKeysInSlot", arg0, arg1)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// Del indicates an expected call of Del.
-func (mr *MockCmdableMockRecorder) Del(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// ClusterCountKeysInSlot indicates an expected call of ClusterCountKeysInSlot.
+func (mr *MockCmdableMockRecorder) ClusterCountKeysInSlot(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockCmdable)(nil).Del), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterCountKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterCountKeysInSlot), arg0, arg1)
 }
 
-// Dump mocks base method.
-func (m *MockCmdable) Dump(arg0 context.Context, arg1 string) *redis.StringCmd {
+// ClusterDelSlots mocks base method.
+func (m *MockCmdable) ClusterDelSlots(arg0 context.Context, arg1 ...int) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Dump", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// Dump indicates an expected call of Dump.
-func (mr *MockCmdableMockRecorder) Dump(arg0, arg1 interface{}) *gomock.Call {
+// ClusterDelSlots indicates an expected call of ClusterDelSlots.
+func (mr *MockCmdableMockRecorder) ClusterDelSlots(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockCmdable)(nil).Dump), arg0, arg1)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlots), varargs...)
 }
 
-// Echo mocks base method.
-func (m *MockCmdable) Echo(arg0 context.Context, arg1 interface{}) *redis.StringCmd {
+// ClusterDelSlotsRange mocks base method.
+func (m *MockCmdable) ClusterDelSlotsRange(arg0 context.Context, arg1, arg2 int) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Echo", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "ClusterDelSlotsRange", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Echo indicates an expected call of Echo.
-func (mr *MockCmdableMockRecorder) Echo(arg0, arg1 interface{}) *gomock.Call {
+// ClusterDelSlotsRange indicates an expected call of ClusterDelSlotsRange.
+func (mr *MockCmdableMockRecorder) ClusterDelSlotsRange(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockCmdable)(nil).Echo), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterDelSlotsRange", reflect.TypeOf((*MockCmdable)(nil).ClusterDelSlotsRange), arg0, arg1, arg2)
 }
 
-// Eval mocks base method.
-func (m *MockCmdable) Eval(arg0 context.Context, arg1 string, arg2 []string, arg3 ...interface{}) *redis.Cmd {
+// ClusterFailover mocks base method.
+func (m *MockCmdable) ClusterFailover(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "Eval", varargs...)
-	ret0, _ := ret[0].(*redis.Cmd)
+	ret := m.ctrl.Call(m, "ClusterFailover", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Eval indicates an expected call of Eval.
-func (mr *MockCmdableMockRecorder) Eval(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+// ClusterFailover indicates an expected call of ClusterFailover.
+func (mr *MockCmdableMockRecorder) ClusterFailover(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockCmdable)(nil).Eval), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterFailover", reflect.TypeOf((*MockCmdable)(nil).ClusterFailover), arg0)
 }
 
-// EvalRO mocks base method.
-func (m *MockCmdable) EvalRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...interface{}) *redis.Cmd {
+// ClusterForget mocks base method.
+func (m *MockCmdable) ClusterForget(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EvalRO", varargs...)
-	ret0, _ := ret[0].(*redis.Cmd)
+	ret := m.ctrl.Call(m, "ClusterForget", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// EvalRO indicates an expected call of EvalRO.
-func (mr *MockCmdableMockRecorder) EvalRO(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+// ClusterForget indicates an expected call of ClusterForget.
+func (mr *MockCmdableMockRecorder) ClusterForget(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockCmdable)(nil).EvalRO), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterForget", reflect.TypeOf((*MockCmdable)(nil).ClusterForget), arg0, arg1)
 }
 
-// EvalSha mocks base method.
-func (m *MockCmdable) EvalSha(arg0 context.Context, arg1 string, arg2 []string, arg3 ...interface{}) *redis.Cmd {
+// ClusterGetKeysInSlot mocks base method.
+func (m *MockCmdable) ClusterGetKeysInSlot(arg0 context.Context, arg1, arg2 int) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EvalSha", varargs...)
-	ret0, _ := ret[0].(*redis.Cmd)
+	ret := m.ctrl.Call(m, "ClusterGetKeysInSlot", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// EvalSha indicates an expected call of EvalSha.
-func (mr *MockCmdableMockRecorder) EvalSha(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+// ClusterGetKeysInSlot indicates an expected call of ClusterGetKeysInSlot.
+func (mr *MockCmdableMockRecorder) ClusterGetKeysInSlot(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockCmdable)(nil).EvalSha), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterGetKeysInSlot", reflect.TypeOf((*MockCmdable)(nil).ClusterGetKeysInSlot), arg0, arg1, arg2)
 }
 
-// EvalShaRO mocks base method.
-func (m *MockCmdable) EvalShaRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...interface{}) *redis.Cmd {
+// ClusterInfo mocks base method.
+func (m *MockCmdable) ClusterInfo(arg0 context.Context) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
-	for _, a := range arg3 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "EvalShaRO", varargs...)
-	ret0, _ := ret[0].(*redis.Cmd)
+	ret := m.ctrl.Call(m, "ClusterInfo", arg0)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// EvalShaRO indicates an expected call of EvalShaRO.
-func (mr *MockCmdableMockRecorder) EvalShaRO(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+// ClusterInfo indicates an expected call of ClusterInfo.
+func (mr *MockCmdableMockRecorder) ClusterInfo(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockCmdable)(nil).EvalShaRO), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterInfo", reflect.TypeOf((*MockCmdable)(nil).ClusterInfo), arg0)
 }
 
-// Exists mocks base method.
-func (m *MockCmdable) Exists(arg0 context.Context, arg1 ...string) *redis.IntCmd {
+// ClusterKeySlot mocks base method.
+func (m *MockCmdable) ClusterKeySlot(arg0 context.Context, arg1 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "Exists", varargs...)
+	ret := m.ctrl.Call(m, "ClusterKeySlot", arg0, arg1)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// Exists indicates an expected call of Exists.
-func (mr *MockCmdableMockRecorder) Exists(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// ClusterKeySlot indicates an expected call of ClusterKeySlot.
+func (mr *MockCmdableMockRecorder) ClusterKeySlot(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockCmdable)(nil).Exists), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterKeySlot", reflect.TypeOf((*MockCmdable)(nil).ClusterKeySlot), arg0, arg1)
 }
 
-// Expire mocks base method.
-func (m *MockCmdable) Expire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
+// ClusterLinks mocks base method.
+func (m *MockCmdable) ClusterLinks(arg0 context.Context) *redis.ClusterLinksCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Expire", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ClusterLinks", arg0)
+	ret0, _ := ret[0].(*redis.ClusterLinksCmd)
 	return ret0
 }
 
-// Expire indicates an expected call of Expire.
-func (mr *MockCmdableMockRecorder) Expire(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterLinks indicates an expected call of ClusterLinks.
+func (mr *MockCmdableMockRecorder) ClusterLinks(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockCmdable)(nil).Expire), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterLinks", reflect.TypeOf((*MockCmdable)(nil).ClusterLinks), arg0)
 }
 
-// ExpireAt mocks base method.
-func (m *MockCmdable) ExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd {
+// ClusterMeet mocks base method.
+func (m *MockCmdable) ClusterMeet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExpireAt", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ClusterMeet", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ExpireAt indicates an expected call of ExpireAt.
-func (mr *MockCmdableMockRecorder) ExpireAt(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterMeet indicates an expected call of ClusterMeet.
+func (mr *MockCmdableMockRecorder) ClusterMeet(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockCmdable)(nil).ExpireAt), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMeet", reflect.TypeOf((*MockCmdable)(nil).ClusterMeet), arg0, arg1, arg2)
 }
 
-// ExpireGT mocks base method.
-func (m *MockCmdable) ExpireGT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
+// ClusterMyShardID mocks base method.
+func (m *MockCmdable) ClusterMyShardID(arg0 context.Context) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExpireGT", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ClusterMyShardID", arg0)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// ExpireGT indicates an expected call of ExpireGT.
-func (mr *MockCmdableMockRecorder) ExpireGT(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterMyShardID indicates an expected call of ClusterMyShardID.
+func (mr *MockCmdableMockRecorder) ClusterMyShardID(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockCmdable)(nil).ExpireGT), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterMyShardID", reflect.TypeOf((*MockCmdable)(nil).ClusterMyShardID), arg0)
 }
 
-// ExpireLT mocks base method.
-func (m *MockCmdable) ExpireLT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
+// ClusterNodes mocks base method.
+func (m *MockCmdable) ClusterNodes(arg0 context.Context) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExpireLT", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ClusterNodes", arg0)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// ExpireLT indicates an expected call of ExpireLT.
-func (mr *MockCmdableMockRecorder) ExpireLT(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterNodes indicates an expected call of ClusterNodes.
+func (mr *MockCmdableMockRecorder) ClusterNodes(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockCmdable)(nil).ExpireLT), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterNodes", reflect.TypeOf((*MockCmdable)(nil).ClusterNodes), arg0)
 }
 
-// ExpireNX mocks base method.
-func (m *MockCmdable) ExpireNX(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
+// ClusterReplicate mocks base method.
+func (m *MockCmdable) ClusterReplicate(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExpireNX", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ClusterReplicate", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ExpireNX indicates an expected call of ExpireNX.
-func (mr *MockCmdableMockRecorder) ExpireNX(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterReplicate indicates an expected call of ClusterReplicate.
+func (mr *MockCmdableMockRecorder) ClusterReplicate(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockCmdable)(nil).ExpireNX), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterReplicate", reflect.TypeOf((*MockCmdable)(nil).ClusterReplicate), arg0, arg1)
 }
 
-// ExpireXX mocks base method.
-func (m *MockCmdable) ExpireXX(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
+// ClusterResetHard mocks base method.
+func (m *MockCmdable) ClusterResetHard(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ExpireXX", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ClusterResetHard", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ExpireXX indicates an expected call of ExpireXX.
-func (mr *MockCmdableMockRecorder) ExpireXX(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ClusterResetHard indicates an expected call of ClusterResetHard.
+func (mr *MockCmdableMockRecorder) ClusterResetHard(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockCmdable)(nil).ExpireXX), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetHard", reflect.TypeOf((*MockCmdable)(nil).ClusterResetHard), arg0)
 }
 
-// FlushAll mocks base method.
-func (m *MockCmdable) FlushAll(arg0 context.Context) *redis.StatusCmd {
+// ClusterResetSoft mocks base method.
+func (m *MockCmdable) ClusterResetSoft(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FlushAll", arg0)
+	ret := m.ctrl.Call(m, "ClusterResetSoft", arg0)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// FlushAll indicates an expected call of FlushAll.
-func (mr *MockCmdableMockRecorder) FlushAll(arg0 interface{}) *gomock.Call {
+// ClusterResetSoft indicates an expected call of ClusterResetSoft.
+func (mr *MockCmdableMockRecorder) ClusterResetSoft(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockCmdable)(nil).FlushAll), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResetSoft", reflect.TypeOf((*MockCmdable)(nil).ClusterResetSoft), arg0)
 }
 
-// FlushAllAsync mocks base method.
-func (m *MockCmdable) FlushAllAsync(arg0 context.Context) *redis.StatusCmd {
+// ClusterSaveConfig mocks base method.
+func (m *MockCmdable) ClusterSaveConfig(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FlushAllAsync", arg0)
+	ret := m.ctrl.Call(m, "ClusterSaveConfig", arg0)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// FlushAllAsync indicates an expected call of FlushAllAsync.
-func (mr *MockCmdableMockRecorder) FlushAllAsync(arg0 interface{}) *gomock.Call {
+// ClusterSaveConfig indicates an expected call of ClusterSaveConfig.
+func (mr *MockCmdableMockRecorder) ClusterSaveConfig(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockCmdable)(nil).FlushAllAsync), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSaveConfig", reflect.TypeOf((*MockCmdable)(nil).ClusterSaveConfig), arg0)
 }
 
-// FlushDB mocks base method.
-func (m *MockCmdable) FlushDB(arg0 context.Context) *redis.StatusCmd {
+// ClusterShards mocks base method.
+func (m *MockCmdable) ClusterShards(arg0 context.Context) *redis.ClusterShardsCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FlushDB", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "ClusterShards", arg0)
+	ret0, _ := ret[0].(*redis.ClusterShardsCmd)
 	return ret0
 }
 
-// FlushDB indicates an expected call of FlushDB.
-func (mr *MockCmdableMockRecorder) FlushDB(arg0 interface{}) *gomock.Call {
+// ClusterShards indicates an expected call of ClusterShards.
+func (mr *MockCmdableMockRecorder) ClusterShards(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockCmdable)(nil).FlushDB), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterShards", reflect.TypeOf((*MockCmdable)(nil).ClusterShards), arg0)
 }
 
-// FlushDBAsync mocks base method.
-func (m *MockCmdable) FlushDBAsync(arg0 context.Context) *redis.StatusCmd {
+// ClusterSlaves mocks base method.
+func (m *MockCmdable) ClusterSlaves(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "FlushDBAsync", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "ClusterSlaves", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// FlushDBAsync indicates an expected call of FlushDBAsync.
-func (mr *MockCmdableMockRecorder) FlushDBAsync(arg0 interface{}) *gomock.Call {
+// ClusterSlaves indicates an expected call of ClusterSlaves.
+func (mr *MockCmdableMockRecorder) ClusterSlaves(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockCmdable)(nil).FlushDBAsync), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlaves", reflect.TypeOf((*MockCmdable)(nil).ClusterSlaves), arg0, arg1)
 }
 
-// GeoAdd mocks base method.
-func (m *MockCmdable) GeoAdd(arg0 context.Context, arg1 string, arg2 ...*redis.GeoLocation) *redis.IntCmd {
+// ClusterSlots mocks base method.
+func (m *MockCmdable) ClusterSlots(arg0 context.Context) *redis.ClusterSlotsCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "GeoAdd", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ClusterSlots", arg0)
+	ret0, _ := ret[0].(*redis.ClusterSlotsCmd)
 	return ret0
 }
 
-// GeoAdd indicates an expected call of GeoAdd.
-func (mr *MockCmdableMockRecorder) GeoAdd(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ClusterSlots indicates an expected call of ClusterSlots.
+func (mr *MockCmdableMockRecorder) ClusterSlots(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoAdd", reflect.TypeOf((*MockCmdable)(nil).GeoAdd), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterSlots", reflect.TypeOf((*MockCmdable)(nil).ClusterSlots), arg0)
 }
 
-// GeoDist mocks base method.
-func (m *MockCmdable) GeoDist(arg0 context.Context, arg1, arg2, arg3, arg4 string) *redis.FloatCmd {
+// Command mocks base method.
+func (m *MockCmdable) Command(arg0 context.Context) *redis.CommandsInfoCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoDist", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.FloatCmd)
+	ret := m.ctrl.Call(m, "Command", arg0)
+	ret0, _ := ret[0].(*redis.CommandsInfoCmd)
 	return ret0
 }
 
-// GeoDist indicates an expected call of GeoDist.
-func (mr *MockCmdableMockRecorder) GeoDist(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// Command indicates an expected call of Command.
+func (mr *MockCmdableMockRecorder) Command(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockCmdable)(nil).GeoDist), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Command", reflect.TypeOf((*MockCmdable)(nil).Command), arg0)
 }
 
-// GeoHash mocks base method.
-func (m *MockCmdable) GeoHash(arg0 context.Context, arg1 string, arg2 ...string) *redis.StringSliceCmd {
+// CommandGetKeys mocks base method.
+func (m *MockCmdable) CommandGetKeys(arg0 context.Context, arg1 ...any) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{arg0}
+	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "GeoHash", varargs...)
+	ret := m.ctrl.Call(m, "CommandGetKeys", varargs...)
 	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// GeoHash indicates an expected call of GeoHash.
-func (mr *MockCmdableMockRecorder) GeoHash(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CommandGetKeys indicates an expected call of CommandGetKeys.
+func (mr *MockCmdableMockRecorder) CommandGetKeys(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoHash", reflect.TypeOf((*MockCmdable)(nil).GeoHash), varargs...)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeys", reflect.TypeOf((*MockCmdable)(nil).CommandGetKeys), varargs...)
 }
 
-// GeoPos mocks base method.
-func (m *MockCmdable) GeoPos(arg0 context.Context, arg1 string, arg2 ...string) *redis.GeoPosCmd {
+// CommandGetKeysAndFlags mocks base method.
+func (m *MockCmdable) CommandGetKeysAndFlags(arg0 context.Context, arg1 ...any) *redis.KeyFlagsCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{arg0}
+	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "GeoPos", varargs...)
-	ret0, _ := ret[0].(*redis.GeoPosCmd)
+	ret := m.ctrl.Call(m, "CommandGetKeysAndFlags", varargs...)
+	ret0, _ := ret[0].(*redis.KeyFlagsCmd)
 	return ret0
 }
 
-// GeoPos indicates an expected call of GeoPos.
-func (mr *MockCmdableMockRecorder) GeoPos(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// CommandGetKeysAndFlags indicates an expected call of CommandGetKeysAndFlags.
+func (mr *MockCmdableMockRecorder) CommandGetKeysAndFlags(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoPos", reflect.TypeOf((*MockCmdable)(nil).GeoPos), varargs...)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandGetKeysAndFlags", reflect.TypeOf((*MockCmdable)(nil).CommandGetKeysAndFlags), varargs...)
 }
 
-// GeoRadius mocks base method.
-func (m *MockCmdable) GeoRadius(arg0 context.Context, arg1 string, arg2, arg3 float64, arg4 *redis.GeoRadiusQuery) *redis.GeoLocationCmd {
+// CommandList mocks base method.
+func (m *MockCmdable) CommandList(arg0 context.Context, arg1 *redis.FilterBy) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoRadius", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.GeoLocationCmd)
+	ret := m.ctrl.Call(m, "CommandList", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// GeoRadius indicates an expected call of GeoRadius.
-func (mr *MockCmdableMockRecorder) GeoRadius(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// CommandList indicates an expected call of CommandList.
+func (mr *MockCmdableMockRecorder) CommandList(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockCmdable)(nil).GeoRadius), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommandList", reflect.TypeOf((*MockCmdable)(nil).CommandList), arg0, arg1)
 }
 
-// GeoRadiusByMember mocks base method.
-func (m *MockCmdable) GeoRadiusByMember(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoRadiusQuery) *redis.GeoLocationCmd {
+// ConfigGet mocks base method.
+func (m *MockCmdable) ConfigGet(arg0 context.Context, arg1 string) *redis.MapStringStringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoRadiusByMember", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.GeoLocationCmd)
+	ret := m.ctrl.Call(m, "ConfigGet", arg0, arg1)
+	ret0, _ := ret[0].(*redis.MapStringStringCmd)
 	return ret0
 }
 
-// GeoRadiusByMember indicates an expected call of GeoRadiusByMember.
-func (mr *MockCmdableMockRecorder) GeoRadiusByMember(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// ConfigGet indicates an expected call of ConfigGet.
+func (mr *MockCmdableMockRecorder) ConfigGet(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMember), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigGet", reflect.TypeOf((*MockCmdable)(nil).ConfigGet), arg0, arg1)
 }
 
-// GeoRadiusByMemberStore mocks base method.
-func (m *MockCmdable) GeoRadiusByMemberStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoRadiusQuery) *redis.IntCmd {
+// ConfigResetStat mocks base method.
+func (m *MockCmdable) ConfigResetStat(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoRadiusByMemberStore", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ConfigResetStat", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// GeoRadiusByMemberStore indicates an expected call of GeoRadiusByMemberStore.
-func (mr *MockCmdableMockRecorder) GeoRadiusByMemberStore(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// ConfigResetStat indicates an expected call of ConfigResetStat.
+func (mr *MockCmdableMockRecorder) ConfigResetStat(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMemberStore), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigResetStat", reflect.TypeOf((*MockCmdable)(nil).ConfigResetStat), arg0)
 }
 
-// GeoRadiusStore mocks base method.
-func (m *MockCmdable) GeoRadiusStore(arg0 context.Context, arg1 string, arg2, arg3 float64, arg4 *redis.GeoRadiusQuery) *redis.IntCmd {
+// ConfigRewrite mocks base method.
+func (m *MockCmdable) ConfigRewrite(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoRadiusStore", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ConfigRewrite", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// GeoRadiusStore indicates an expected call of GeoRadiusStore.
-func (mr *MockCmdableMockRecorder) GeoRadiusStore(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// ConfigRewrite indicates an expected call of ConfigRewrite.
+func (mr *MockCmdableMockRecorder) ConfigRewrite(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusStore), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigRewrite", reflect.TypeOf((*MockCmdable)(nil).ConfigRewrite), arg0)
 }
 
-// GeoSearch mocks base method.
-func (m *MockCmdable) GeoSearch(arg0 context.Context, arg1 string, arg2 *redis.GeoSearchQuery) *redis.StringSliceCmd {
+// ConfigSet mocks base method.
+func (m *MockCmdable) ConfigSet(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoSearch", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "ConfigSet", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// GeoSearch indicates an expected call of GeoSearch.
-func (mr *MockCmdableMockRecorder) GeoSearch(arg0, arg1, arg2 interface{}) *gomock.Call {
+// ConfigSet indicates an expected call of ConfigSet.
+func (mr *MockCmdableMockRecorder) ConfigSet(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockCmdable)(nil).GeoSearch), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfigSet", reflect.TypeOf((*MockCmdable)(nil).ConfigSet), arg0, arg1, arg2)
 }
 
-// GeoSearchLocation mocks base method.
-func (m *MockCmdable) GeoSearchLocation(arg0 context.Context, arg1 string, arg2 *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd {
+// Copy mocks base method.
+func (m *MockCmdable) Copy(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 bool) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoSearchLocation", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.GeoSearchLocationCmd)
+	ret := m.ctrl.Call(m, "Copy", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// GeoSearchLocation indicates an expected call of GeoSearchLocation.
-func (mr *MockCmdableMockRecorder) GeoSearchLocation(arg0, arg1, arg2 interface{}) *gomock.Call {
+// Copy indicates an expected call of Copy.
+func (mr *MockCmdableMockRecorder) Copy(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockCmdable)(nil).GeoSearchLocation), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockCmdable)(nil).Copy), arg0, arg1, arg2, arg3, arg4)
 }
 
-// GeoSearchStore mocks base method.
-func (m *MockCmdable) GeoSearchStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.GeoSearchStoreQuery) *redis.IntCmd {
+// DBSize mocks base method.
+func (m *MockCmdable) DBSize(arg0 context.Context) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GeoSearchStore", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "DBSize", arg0)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// GeoSearchStore indicates an expected call of GeoSearchStore.
-func (mr *MockCmdableMockRecorder) GeoSearchStore(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// DBSize indicates an expected call of DBSize.
+func (mr *MockCmdableMockRecorder) DBSize(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockCmdable)(nil).GeoSearchStore), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DBSize", reflect.TypeOf((*MockCmdable)(nil).DBSize), arg0)
 }
 
-// Get mocks base method.
-func (m *MockCmdable) Get(arg0 context.Context, arg1 string) *redis.StringCmd {
+// DebugObject mocks base method.
+func (m *MockCmdable) DebugObject(arg0 context.Context, arg1 string) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Get", arg0, arg1)
+	ret := m.ctrl.Call(m, "DebugObject", arg0, arg1)
 	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// Get indicates an expected call of Get.
-func (mr *MockCmdableMockRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
+// DebugObject indicates an expected call of DebugObject.
+func (mr *MockCmdableMockRecorder) DebugObject(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCmdable)(nil).Get), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugObject", reflect.TypeOf((*MockCmdable)(nil).DebugObject), arg0, arg1)
 }
 
-// GetBit mocks base method.
-func (m *MockCmdable) GetBit(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd {
+// Decr mocks base method.
+func (m *MockCmdable) Decr(arg0 context.Context, arg1 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetBit", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Decr", arg0, arg1)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// GetBit indicates an expected call of GetBit.
-func (mr *MockCmdableMockRecorder) GetBit(arg0, arg1, arg2 interface{}) *gomock.Call {
+// Decr indicates an expected call of Decr.
+func (mr *MockCmdableMockRecorder) Decr(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCmdable)(nil).GetBit), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decr", reflect.TypeOf((*MockCmdable)(nil).Decr), arg0, arg1)
 }
 
-// GetDel mocks base method.
-func (m *MockCmdable) GetDel(arg0 context.Context, arg1 string) *redis.StringCmd {
+// DecrBy mocks base method.
+func (m *MockCmdable) DecrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetDel", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "DecrBy", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// GetDel indicates an expected call of GetDel.
-func (mr *MockCmdableMockRecorder) GetDel(arg0, arg1 interface{}) *gomock.Call {
+// DecrBy indicates an expected call of DecrBy.
+func (mr *MockCmdableMockRecorder) DecrBy(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockCmdable)(nil).GetDel), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecrBy", reflect.TypeOf((*MockCmdable)(nil).DecrBy), arg0, arg1, arg2)
 }
 
-// GetEx mocks base method.
-func (m *MockCmdable) GetEx(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.StringCmd {
+// Del mocks base method.
+func (m *MockCmdable) Del(arg0 context.Context, arg1 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetEx", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// GetEx indicates an expected call of GetEx.
-func (mr *MockCmdableMockRecorder) GetEx(arg0, arg1, arg2 interface{}) *gomock.Call {
+// Del indicates an expected call of Del.
+func (mr *MockCmdableMockRecorder) Del(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockCmdable)(nil).GetEx), arg0, arg1, arg2)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Del", reflect.TypeOf((*MockCmdable)(nil).Del), varargs...)
 }
 
-// GetRange mocks base method.
-func (m *MockCmdable) GetRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringCmd {
+// Dump mocks base method.
+func (m *MockCmdable) Dump(arg0 context.Context, arg1 string) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetRange", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "Dump", arg0, arg1)
 	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// GetRange indicates an expected call of GetRange.
-func (mr *MockCmdableMockRecorder) GetRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// Dump indicates an expected call of Dump.
+func (mr *MockCmdableMockRecorder) Dump(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCmdable)(nil).GetRange), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Dump", reflect.TypeOf((*MockCmdable)(nil).Dump), arg0, arg1)
 }
 
-// GetSet mocks base method.
-func (m *MockCmdable) GetSet(arg0 context.Context, arg1 string, arg2 interface{}) *redis.StringCmd {
+// Echo mocks base method.
+func (m *MockCmdable) Echo(arg0 context.Context, arg1 any) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetSet", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "Echo", arg0, arg1)
 	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// GetSet indicates an expected call of GetSet.
-func (mr *MockCmdableMockRecorder) GetSet(arg0, arg1, arg2 interface{}) *gomock.Call {
+// Echo indicates an expected call of Echo.
+func (mr *MockCmdableMockRecorder) Echo(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCmdable)(nil).GetSet), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Echo", reflect.TypeOf((*MockCmdable)(nil).Echo), arg0, arg1)
 }
 
-// HDel mocks base method.
-func (m *MockCmdable) HDel(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
+// Eval mocks base method.
+func (m *MockCmdable) Eval(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{arg0, arg1, arg2}
+	for _, a := range arg3 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "HDel", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "Eval", varargs...)
+	ret0, _ := ret[0].(*redis.Cmd)
 	return ret0
 }
 
-// HDel indicates an expected call of HDel.
-func (mr *MockCmdableMockRecorder) HDel(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// Eval indicates an expected call of Eval.
+func (mr *MockCmdableMockRecorder) Eval(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HDel", reflect.TypeOf((*MockCmdable)(nil).HDel), varargs...)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eval", reflect.TypeOf((*MockCmdable)(nil).Eval), varargs...)
 }
 
-// HExists mocks base method.
-func (m *MockCmdable) HExists(arg0 context.Context, arg1, arg2 string) *redis.BoolCmd {
+// EvalRO mocks base method.
+func (m *MockCmdable) EvalRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HExists", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	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
 }
 
-// HExists indicates an expected call of HExists.
-func (mr *MockCmdableMockRecorder) HExists(arg0, arg1, arg2 interface{}) *gomock.Call {
+// EvalRO indicates an expected call of EvalRO.
+func (mr *MockCmdableMockRecorder) EvalRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCmdable)(nil).HExists), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalRO", reflect.TypeOf((*MockCmdable)(nil).EvalRO), varargs...)
 }
 
-// HGet mocks base method.
-func (m *MockCmdable) HGet(arg0 context.Context, arg1, arg2 string) *redis.StringCmd {
+// EvalSha mocks base method.
+func (m *MockCmdable) EvalSha(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HGet", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// HGet indicates an expected call of HGet.
-func (mr *MockCmdableMockRecorder) HGet(arg0, arg1, arg2 interface{}) *gomock.Call {
+// EvalSha indicates an expected call of EvalSha.
+func (mr *MockCmdableMockRecorder) EvalSha(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCmdable)(nil).HGet), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalSha", reflect.TypeOf((*MockCmdable)(nil).EvalSha), varargs...)
 }
 
-// HGetAll mocks base method.
-func (m *MockCmdable) HGetAll(arg0 context.Context, arg1 string) *redis.MapStringStringCmd {
+// EvalShaRO mocks base method.
+func (m *MockCmdable) EvalShaRO(arg0 context.Context, arg1 string, arg2 []string, arg3 ...any) *redis.Cmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HGetAll", arg0, arg1)
-	ret0, _ := ret[0].(*redis.MapStringStringCmd)
+	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
 }
 
-// HGetAll indicates an expected call of HGetAll.
-func (mr *MockCmdableMockRecorder) HGetAll(arg0, arg1 interface{}) *gomock.Call {
+// EvalShaRO indicates an expected call of EvalShaRO.
+func (mr *MockCmdableMockRecorder) EvalShaRO(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCmdable)(nil).HGetAll), arg0, arg1)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EvalShaRO", reflect.TypeOf((*MockCmdable)(nil).EvalShaRO), varargs...)
 }
 
-// HIncrBy mocks base method.
-func (m *MockCmdable) HIncrBy(arg0 context.Context, arg1, arg2 string, arg3 int64) *redis.IntCmd {
+// Exists mocks base method.
+func (m *MockCmdable) Exists(arg0 context.Context, arg1 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HIncrBy", arg0, arg1, arg2, arg3)
+	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
 }
 
-// HIncrBy indicates an expected call of HIncrBy.
-func (mr *MockCmdableMockRecorder) HIncrBy(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// Exists indicates an expected call of Exists.
+func (mr *MockCmdableMockRecorder) Exists(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCmdable)(nil).HIncrBy), arg0, arg1, arg2, arg3)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exists", reflect.TypeOf((*MockCmdable)(nil).Exists), varargs...)
 }
 
-// HIncrByFloat mocks base method.
-func (m *MockCmdable) HIncrByFloat(arg0 context.Context, arg1, arg2 string, arg3 float64) *redis.FloatCmd {
+// Expire mocks base method.
+func (m *MockCmdable) Expire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HIncrByFloat", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.FloatCmd)
+	ret := m.ctrl.Call(m, "Expire", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// HIncrByFloat indicates an expected call of HIncrByFloat.
-func (mr *MockCmdableMockRecorder) HIncrByFloat(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// Expire indicates an expected call of Expire.
+func (mr *MockCmdableMockRecorder) Expire(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockCmdable)(nil).HIncrByFloat), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Expire", reflect.TypeOf((*MockCmdable)(nil).Expire), arg0, arg1, arg2)
 }
 
-// HKeys mocks base method.
-func (m *MockCmdable) HKeys(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// ExpireAt mocks base method.
+func (m *MockCmdable) ExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HKeys", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "ExpireAt", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// HKeys indicates an expected call of HKeys.
-func (mr *MockCmdableMockRecorder) HKeys(arg0, arg1 interface{}) *gomock.Call {
+// ExpireAt indicates an expected call of ExpireAt.
+func (mr *MockCmdableMockRecorder) ExpireAt(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCmdable)(nil).HKeys), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireAt", reflect.TypeOf((*MockCmdable)(nil).ExpireAt), arg0, arg1, arg2)
 }
 
-// HLen mocks base method.
-func (m *MockCmdable) HLen(arg0 context.Context, arg1 string) *redis.IntCmd {
+// ExpireGT mocks base method.
+func (m *MockCmdable) ExpireGT(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HLen", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
-	return ret0
+	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 *MockCmdableMockRecorder) ExpireGT(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireGT", reflect.TypeOf((*MockCmdable)(nil).ExpireGT), arg0, arg1, arg2)
+}
+
+// ExpireLT mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ExpireLT(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireLT", reflect.TypeOf((*MockCmdable)(nil).ExpireLT), arg0, arg1, arg2)
+}
+
+// ExpireNX mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ExpireNX(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireNX", reflect.TypeOf((*MockCmdable)(nil).ExpireNX), arg0, arg1, arg2)
+}
+
+// ExpireTime mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ExpireTime(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireTime", reflect.TypeOf((*MockCmdable)(nil).ExpireTime), arg0, arg1)
+}
+
+// ExpireXX mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ExpireXX(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExpireXX", reflect.TypeOf((*MockCmdable)(nil).ExpireXX), arg0, arg1, arg2)
+}
+
+// FCall mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).FCall), varargs...)
+}
+
+// FCallRO mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).FCallRO), varargs...)
+}
+
+// FCallRo mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).FCallRo), varargs...)
+}
+
+// FlushAll mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FlushAll(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAll", reflect.TypeOf((*MockCmdable)(nil).FlushAll), arg0)
+}
+
+// FlushAllAsync mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FlushAllAsync(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushAllAsync", reflect.TypeOf((*MockCmdable)(nil).FlushAllAsync), arg0)
+}
+
+// FlushDB mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FlushDB(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDB", reflect.TypeOf((*MockCmdable)(nil).FlushDB), arg0)
+}
+
+// FlushDBAsync mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FlushDBAsync(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FlushDBAsync", reflect.TypeOf((*MockCmdable)(nil).FlushDBAsync), arg0)
+}
+
+// FunctionDelete mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionDelete(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDelete", reflect.TypeOf((*MockCmdable)(nil).FunctionDelete), arg0, arg1)
+}
+
+// FunctionDump mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionDump(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionDump", reflect.TypeOf((*MockCmdable)(nil).FunctionDump), arg0)
+}
+
+// FunctionFlush mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionFlush(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlush", reflect.TypeOf((*MockCmdable)(nil).FunctionFlush), arg0)
+}
+
+// FunctionFlushAsync mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionFlushAsync(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionFlushAsync", reflect.TypeOf((*MockCmdable)(nil).FunctionFlushAsync), arg0)
+}
+
+// FunctionKill mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionKill(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionKill", reflect.TypeOf((*MockCmdable)(nil).FunctionKill), arg0)
+}
+
+// FunctionList mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionList(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionList", reflect.TypeOf((*MockCmdable)(nil).FunctionList), arg0, arg1)
+}
+
+// FunctionLoad mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionLoad(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoad", reflect.TypeOf((*MockCmdable)(nil).FunctionLoad), arg0, arg1)
+}
+
+// FunctionLoadReplace mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionLoadReplace(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionLoadReplace", reflect.TypeOf((*MockCmdable)(nil).FunctionLoadReplace), arg0, arg1)
+}
+
+// FunctionRestore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionRestore(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionRestore", reflect.TypeOf((*MockCmdable)(nil).FunctionRestore), arg0, arg1)
+}
+
+// FunctionStats mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) FunctionStats(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FunctionStats", reflect.TypeOf((*MockCmdable)(nil).FunctionStats), arg0)
+}
+
+// GeoAdd mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).GeoAdd), varargs...)
+}
+
+// GeoDist mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoDist(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoDist", reflect.TypeOf((*MockCmdable)(nil).GeoDist), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GeoHash mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).GeoHash), varargs...)
+}
+
+// GeoPos mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).GeoPos), varargs...)
+}
+
+// GeoRadius mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoRadius(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadius", reflect.TypeOf((*MockCmdable)(nil).GeoRadius), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GeoRadiusByMember mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoRadiusByMember(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMember", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMember), arg0, arg1, arg2, arg3)
+}
+
+// GeoRadiusByMemberStore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoRadiusByMemberStore(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusByMemberStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusByMemberStore), arg0, arg1, arg2, arg3)
+}
+
+// GeoRadiusStore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoRadiusStore(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoRadiusStore", reflect.TypeOf((*MockCmdable)(nil).GeoRadiusStore), arg0, arg1, arg2, arg3, arg4)
+}
+
+// GeoSearch mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoSearch(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearch", reflect.TypeOf((*MockCmdable)(nil).GeoSearch), arg0, arg1, arg2)
+}
+
+// GeoSearchLocation mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoSearchLocation(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchLocation", reflect.TypeOf((*MockCmdable)(nil).GeoSearchLocation), arg0, arg1, arg2)
+}
+
+// GeoSearchStore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GeoSearchStore(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeoSearchStore", reflect.TypeOf((*MockCmdable)(nil).GeoSearchStore), arg0, arg1, arg2, arg3)
+}
+
+// Get mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Get(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockCmdable)(nil).Get), arg0, arg1)
+}
+
+// GetBit mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GetBit(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBit", reflect.TypeOf((*MockCmdable)(nil).GetBit), arg0, arg1, arg2)
+}
+
+// GetDel mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GetDel(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDel", reflect.TypeOf((*MockCmdable)(nil).GetDel), arg0, arg1)
+}
+
+// GetEx mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GetEx(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEx", reflect.TypeOf((*MockCmdable)(nil).GetEx), arg0, arg1, arg2)
+}
+
+// GetRange mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GetRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRange", reflect.TypeOf((*MockCmdable)(nil).GetRange), arg0, arg1, arg2, arg3)
+}
+
+// GetSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) GetSet(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSet", reflect.TypeOf((*MockCmdable)(nil).GetSet), arg0, arg1, arg2)
+}
+
+// HDel mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).HDel), varargs...)
+}
+
+// HExists mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HExists(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HExists", reflect.TypeOf((*MockCmdable)(nil).HExists), arg0, arg1, arg2)
+}
+
+// HGet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HGet(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGet", reflect.TypeOf((*MockCmdable)(nil).HGet), arg0, arg1, arg2)
+}
+
+// HGetAll mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HGetAll(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HGetAll", reflect.TypeOf((*MockCmdable)(nil).HGetAll), arg0, arg1)
+}
+
+// HIncrBy mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HIncrBy(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrBy", reflect.TypeOf((*MockCmdable)(nil).HIncrBy), arg0, arg1, arg2, arg3)
+}
+
+// HIncrByFloat mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HIncrByFloat(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HIncrByFloat", reflect.TypeOf((*MockCmdable)(nil).HIncrByFloat), arg0, arg1, arg2, arg3)
+}
+
+// HKeys mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HKeys(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HKeys", reflect.TypeOf((*MockCmdable)(nil).HKeys), arg0, arg1)
+}
+
+// HLen mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HLen(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCmdable)(nil).HLen), arg0, arg1)
+}
+
+// HMGet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).HMGet), varargs...)
+}
+
+// HMSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).HMSet), varargs...)
+}
+
+// HRandField mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HRandField(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockCmdable)(nil).HRandField), arg0, arg1, arg2)
+}
+
+// HRandFieldWithValues mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HRandFieldWithValues(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockCmdable)(nil).HRandFieldWithValues), arg0, arg1, arg2)
+}
+
+// HScan mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HScan(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockCmdable)(nil).HScan), arg0, arg1, arg2, arg3, arg4)
+}
+
+// HSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).HSet), varargs...)
+}
+
+// HSetNX mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HSetNX(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockCmdable)(nil).HSetNX), arg0, arg1, arg2, arg3)
+}
+
+// HVals mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) HVals(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockCmdable)(nil).HVals), arg0, arg1)
+}
+
+// Incr mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Incr(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockCmdable)(nil).Incr), arg0, arg1)
+}
+
+// IncrBy mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) IncrBy(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockCmdable)(nil).IncrBy), arg0, arg1, arg2)
+}
+
+// IncrByFloat mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) IncrByFloat(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockCmdable)(nil).IncrByFloat), arg0, arg1, arg2)
+}
+
+// Info mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).Info), varargs...)
+}
+
+// JSONArrAppend mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONArrAppend), varargs...)
+}
+
+// JSONArrIndex mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONArrIndex), varargs...)
+}
+
+// JSONArrIndexWithArgs mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONArrIndexWithArgs), varargs...)
+}
+
+// JSONArrInsert mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONArrInsert), varargs...)
+}
+
+// JSONArrLen mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONArrLen(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrLen", reflect.TypeOf((*MockCmdable)(nil).JSONArrLen), arg0, arg1, arg2)
+}
+
+// JSONArrPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONArrPop(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrPop", reflect.TypeOf((*MockCmdable)(nil).JSONArrPop), arg0, arg1, arg2, arg3)
+}
+
+// JSONArrTrim mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONArrTrim(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrim", reflect.TypeOf((*MockCmdable)(nil).JSONArrTrim), arg0, arg1, arg2)
+}
+
+// JSONArrTrimWithArgs mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONArrTrimWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONArrTrimWithArgs", reflect.TypeOf((*MockCmdable)(nil).JSONArrTrimWithArgs), arg0, arg1, arg2, arg3)
+}
+
+// JSONClear mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONClear(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONClear", reflect.TypeOf((*MockCmdable)(nil).JSONClear), arg0, arg1, arg2)
+}
+
+// JSONDebugMemory mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONDebugMemory(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDebugMemory", reflect.TypeOf((*MockCmdable)(nil).JSONDebugMemory), arg0, arg1, arg2)
+}
+
+// JSONDel mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONDel(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONDel", reflect.TypeOf((*MockCmdable)(nil).JSONDel), arg0, arg1, arg2)
+}
+
+// JSONForget mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONForget(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONForget", reflect.TypeOf((*MockCmdable)(nil).JSONForget), arg0, arg1, arg2)
+}
+
+// JSONGet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONGet), varargs...)
+}
+
+// JSONGetWithArgs mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONGetWithArgs), varargs...)
+}
+
+// JSONMGet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONMGet), varargs...)
+}
+
+// JSONMSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).JSONMSet), varargs...)
+}
+
+// JSONMSetArgs mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONMSetArgs(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMSetArgs", reflect.TypeOf((*MockCmdable)(nil).JSONMSetArgs), arg0, arg1)
+}
+
+// JSONMerge mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONMerge(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONMerge", reflect.TypeOf((*MockCmdable)(nil).JSONMerge), arg0, arg1, arg2, arg3)
+}
+
+// JSONNumIncrBy mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONNumIncrBy(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONNumIncrBy", reflect.TypeOf((*MockCmdable)(nil).JSONNumIncrBy), arg0, arg1, arg2, arg3)
+}
+
+// JSONObjKeys mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONObjKeys(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjKeys", reflect.TypeOf((*MockCmdable)(nil).JSONObjKeys), arg0, arg1, arg2)
+}
+
+// JSONObjLen mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONObjLen(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONObjLen", reflect.TypeOf((*MockCmdable)(nil).JSONObjLen), arg0, arg1, arg2)
+}
+
+// JSONSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONSet(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSet", reflect.TypeOf((*MockCmdable)(nil).JSONSet), arg0, arg1, arg2, arg3)
+}
+
+// JSONSetMode mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONSetMode(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONSetMode", reflect.TypeOf((*MockCmdable)(nil).JSONSetMode), arg0, arg1, arg2, arg3, arg4)
+}
+
+// JSONStrAppend mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONStrAppend(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrAppend", reflect.TypeOf((*MockCmdable)(nil).JSONStrAppend), arg0, arg1, arg2, arg3)
+}
+
+// JSONStrLen mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONStrLen(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONStrLen", reflect.TypeOf((*MockCmdable)(nil).JSONStrLen), arg0, arg1, arg2)
+}
+
+// JSONToggle mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONToggle(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONToggle", reflect.TypeOf((*MockCmdable)(nil).JSONToggle), arg0, arg1, arg2)
+}
+
+// JSONType mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) JSONType(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSONType", reflect.TypeOf((*MockCmdable)(nil).JSONType), arg0, arg1, arg2)
+}
+
+// Keys mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Keys(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockCmdable)(nil).Keys), arg0, arg1)
+}
+
+// LCS mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LCS(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LCS", reflect.TypeOf((*MockCmdable)(nil).LCS), arg0, arg1)
+}
+
+// LIndex mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LIndex(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCmdable)(nil).LIndex), arg0, arg1, arg2)
+}
+
+// LInsert mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LInsert(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockCmdable)(nil).LInsert), arg0, arg1, arg2, arg3, arg4)
+}
+
+// LInsertAfter mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LInsertAfter(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockCmdable)(nil).LInsertAfter), arg0, arg1, arg2, arg3)
+}
+
+// LInsertBefore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LInsertBefore(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockCmdable)(nil).LInsertBefore), arg0, arg1, arg2, arg3)
+}
+
+// LLen mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LLen(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCmdable)(nil).LLen), arg0, arg1)
+}
+
+// LMPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).LMPop), varargs...)
+}
+
+// LMove mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LMove(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockCmdable)(nil).LMove), arg0, arg1, arg2, arg3, arg4)
+}
+
+// LPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LPop(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCmdable)(nil).LPop), arg0, arg1)
+}
+
+// LPopCount mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LPopCount(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockCmdable)(nil).LPopCount), arg0, arg1, arg2)
+}
+
+// LPos mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LPos(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockCmdable)(nil).LPos), arg0, arg1, arg2, arg3)
+}
+
+// LPosCount mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LPosCount(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockCmdable)(nil).LPosCount), arg0, arg1, arg2, arg3, arg4)
+}
+
+// LPush mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).LPush), varargs...)
+}
+
+// LPushX mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).LPushX), varargs...)
+}
+
+// LRange mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCmdable)(nil).LRange), arg0, arg1, arg2, arg3)
+}
+
+// LRem mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LRem(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCmdable)(nil).LRem), arg0, arg1, arg2, arg3)
+}
+
+// LSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LSet(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCmdable)(nil).LSet), arg0, arg1, arg2, arg3)
+}
+
+// LTrim mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LTrim(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCmdable)(nil).LTrim), arg0, arg1, arg2, arg3)
+}
+
+// LastSave mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) LastSave(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockCmdable)(nil).LastSave), arg0)
+}
+
+// MGet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).MGet), varargs...)
+}
+
+// MSet mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).MSet), varargs...)
+}
+
+// MSetNX mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).MSetNX), varargs...)
+}
+
+// MemoryUsage mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).MemoryUsage), varargs...)
+}
+
+// Migrate mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).Migrate), arg0, arg1, arg2, arg3, arg4, arg5)
+}
+
+// ModuleLoadex mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ModuleLoadex(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModuleLoadex", reflect.TypeOf((*MockCmdable)(nil).ModuleLoadex), arg0, arg1)
+}
+
+// Move mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Move(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockCmdable)(nil).Move), arg0, arg1, arg2)
+}
+
+// ObjectEncoding mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ObjectEncoding(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockCmdable)(nil).ObjectEncoding), arg0, arg1)
+}
+
+// ObjectIdleTime mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ObjectIdleTime(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockCmdable)(nil).ObjectIdleTime), arg0, arg1)
+}
+
+// ObjectRefCount mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ObjectRefCount(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockCmdable)(nil).ObjectRefCount), arg0, arg1)
+}
+
+// PExpire mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) PExpire(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockCmdable)(nil).PExpire), arg0, arg1, arg2)
+}
+
+// PExpireAt mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) PExpireAt(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockCmdable)(nil).PExpireAt), arg0, arg1, arg2)
+}
+
+// PExpireTime mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) PExpireTime(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireTime", reflect.TypeOf((*MockCmdable)(nil).PExpireTime), arg0, arg1)
+}
+
+// PFAdd mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).PFAdd), varargs...)
+}
+
+// PFCount mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).PFCount), varargs...)
+}
+
+// PFMerge mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).PFMerge), varargs...)
+}
+
+// PTTL mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) PTTL(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockCmdable)(nil).PTTL), arg0, arg1)
+}
+
+// Persist mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Persist(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockCmdable)(nil).Persist), arg0, arg1)
+}
+
+// Ping mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Ping(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCmdable)(nil).Ping), arg0)
+}
+
+// Pipeline mocks base method.
+func (m *MockCmdable) Pipeline() redis.Pipeliner {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Pipeline")
+	ret0, _ := ret[0].(redis.Pipeliner)
+	return ret0
+}
+
+// Pipeline indicates an expected call of Pipeline.
+func (mr *MockCmdableMockRecorder) Pipeline() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockCmdable)(nil).Pipeline))
+}
+
+// Pipelined mocks base method.
+func (m *MockCmdable) Pipelined(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 *MockCmdableMockRecorder) Pipelined(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockCmdable)(nil).Pipelined), arg0, arg1)
+}
+
+// PubSubChannels mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) PubSubChannels(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubChannels), arg0, arg1)
+}
+
+// PubSubNumPat mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) PubSubNumPat(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockCmdable)(nil).PubSubNumPat), arg0)
+}
+
+// PubSubNumSub mocks base method.
+func (m *MockCmdable) 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
 }
 
-// HLen indicates an expected call of HLen.
-func (mr *MockCmdableMockRecorder) HLen(arg0, arg1 interface{}) *gomock.Call {
+// PubSubNumSub indicates an expected call of PubSubNumSub.
+func (mr *MockCmdableMockRecorder) PubSubNumSub(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HLen", reflect.TypeOf((*MockCmdable)(nil).HLen), arg0, arg1)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubNumSub), varargs...)
 }
 
-// HMGet mocks base method.
-func (m *MockCmdable) HMGet(arg0 context.Context, arg1 string, arg2 ...string) *redis.SliceCmd {
+// PubSubShardChannels mocks base method.
+func (m *MockCmdable) PubSubShardChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "HMGet", varargs...)
-	ret0, _ := ret[0].(*redis.SliceCmd)
+	ret := m.ctrl.Call(m, "PubSubShardChannels", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// HMGet indicates an expected call of HMGet.
-func (mr *MockCmdableMockRecorder) HMGet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PubSubShardChannels indicates an expected call of PubSubShardChannels.
+func (mr *MockCmdableMockRecorder) PubSubShardChannels(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMGet", reflect.TypeOf((*MockCmdable)(nil).HMGet), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubShardChannels), arg0, arg1)
 }
 
-// HMSet mocks base method.
-func (m *MockCmdable) HMSet(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.BoolCmd {
+// PubSubShardNumSub mocks base method.
+func (m *MockCmdable) PubSubShardNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
+	varargs := []any{arg0}
+	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "HMSet", varargs...)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...)
+	ret0, _ := ret[0].(*redis.MapStringIntCmd)
 	return ret0
 }
 
-// HMSet indicates an expected call of HMSet.
-func (mr *MockCmdableMockRecorder) HMSet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// PubSubShardNumSub indicates an expected call of PubSubShardNumSub.
+func (mr *MockCmdableMockRecorder) PubSubShardNumSub(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HMSet", reflect.TypeOf((*MockCmdable)(nil).HMSet), varargs...)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubShardNumSub), varargs...)
 }
 
-// HRandField mocks base method.
-func (m *MockCmdable) HRandField(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd {
+// Publish mocks base method.
+func (m *MockCmdable) Publish(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HRandField", arg0, arg1, arg2)
+	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 *MockCmdableMockRecorder) Publish(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockCmdable)(nil).Publish), arg0, arg1, arg2)
+}
+
+// Quit mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Quit(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockCmdable)(nil).Quit), arg0)
+}
+
+// RPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) RPop(arg0, arg1 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCmdable)(nil).RPop), arg0, arg1)
+}
+
+// RPopCount mocks base method.
+func (m *MockCmdable) 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
 }
 
-// HRandField indicates an expected call of HRandField.
-func (mr *MockCmdableMockRecorder) HRandField(arg0, arg1, arg2 interface{}) *gomock.Call {
+// RPopCount indicates an expected call of RPopCount.
+func (mr *MockCmdableMockRecorder) RPopCount(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandField", reflect.TypeOf((*MockCmdable)(nil).HRandField), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockCmdable)(nil).RPopCount), arg0, arg1, arg2)
 }
 
-// HRandFieldWithValues mocks base method.
-func (m *MockCmdable) HRandFieldWithValues(arg0 context.Context, arg1 string, arg2 int) *redis.KeyValueSliceCmd {
+// RPopLPush mocks base method.
+func (m *MockCmdable) RPopLPush(arg0 context.Context, arg1, arg2 string) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HRandFieldWithValues", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.KeyValueSliceCmd)
+	ret := m.ctrl.Call(m, "RPopLPush", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// HRandFieldWithValues indicates an expected call of HRandFieldWithValues.
-func (mr *MockCmdableMockRecorder) HRandFieldWithValues(arg0, arg1, arg2 interface{}) *gomock.Call {
+// RPopLPush indicates an expected call of RPopLPush.
+func (mr *MockCmdableMockRecorder) RPopLPush(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HRandFieldWithValues", reflect.TypeOf((*MockCmdable)(nil).HRandFieldWithValues), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockCmdable)(nil).RPopLPush), arg0, arg1, arg2)
 }
 
-// HScan mocks base method.
-func (m *MockCmdable) HScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd {
+// RPush mocks base method.
+func (m *MockCmdable) RPush(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HScan", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.ScanCmd)
+	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
 }
 
-// HScan indicates an expected call of HScan.
-func (mr *MockCmdableMockRecorder) HScan(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// RPush indicates an expected call of RPush.
+func (mr *MockCmdableMockRecorder) RPush(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HScan", reflect.TypeOf((*MockCmdable)(nil).HScan), arg0, arg1, arg2, arg3, arg4)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockCmdable)(nil).RPush), varargs...)
 }
 
-// HSet mocks base method.
-func (m *MockCmdable) HSet(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// RPushX mocks base method.
+func (m *MockCmdable) RPushX(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "HSet", varargs...)
+	ret := m.ctrl.Call(m, "RPushX", varargs...)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// HSet indicates an expected call of HSet.
-func (mr *MockCmdableMockRecorder) HSet(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// RPushX indicates an expected call of RPushX.
+func (mr *MockCmdableMockRecorder) RPushX(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSet", reflect.TypeOf((*MockCmdable)(nil).HSet), varargs...)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockCmdable)(nil).RPushX), varargs...)
 }
 
-// HSetNX mocks base method.
-func (m *MockCmdable) HSetNX(arg0 context.Context, arg1, arg2 string, arg3 interface{}) *redis.BoolCmd {
+// RandomKey mocks base method.
+func (m *MockCmdable) RandomKey(arg0 context.Context) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HSetNX", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "RandomKey", arg0)
+	ret0, _ := ret[0].(*redis.StringCmd)
+	return ret0
+}
+
+// RandomKey indicates an expected call of RandomKey.
+func (mr *MockCmdableMockRecorder) RandomKey(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockCmdable)(nil).RandomKey), arg0)
+}
+
+// ReadOnly mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ReadOnly(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockCmdable)(nil).ReadOnly), arg0)
+}
+
+// ReadWrite mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ReadWrite(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockCmdable)(nil).ReadWrite), arg0)
+}
+
+// Rename mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) Rename(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockCmdable)(nil).Rename), arg0, arg1, arg2)
+}
+
+// RenameNX mocks base method.
+func (m *MockCmdable) 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
 }
 
-// HSetNX indicates an expected call of HSetNX.
-func (mr *MockCmdableMockRecorder) HSetNX(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// RenameNX indicates an expected call of RenameNX.
+func (mr *MockCmdableMockRecorder) RenameNX(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HSetNX", reflect.TypeOf((*MockCmdable)(nil).HSetNX), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockCmdable)(nil).RenameNX), arg0, arg1, arg2)
 }
 
-// HVals mocks base method.
-func (m *MockCmdable) HVals(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// Restore mocks base method.
+func (m *MockCmdable) Restore(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "HVals", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "Restore", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// HVals indicates an expected call of HVals.
-func (mr *MockCmdableMockRecorder) HVals(arg0, arg1 interface{}) *gomock.Call {
+// Restore indicates an expected call of Restore.
+func (mr *MockCmdableMockRecorder) Restore(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HVals", reflect.TypeOf((*MockCmdable)(nil).HVals), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockCmdable)(nil).Restore), arg0, arg1, arg2, arg3)
 }
 
-// Incr mocks base method.
-func (m *MockCmdable) Incr(arg0 context.Context, arg1 string) *redis.IntCmd {
+// RestoreReplace mocks base method.
+func (m *MockCmdable) RestoreReplace(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Incr", arg0, arg1)
+	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 *MockCmdableMockRecorder) RestoreReplace(arg0, arg1, arg2, arg3 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockCmdable)(nil).RestoreReplace), arg0, arg1, arg2, arg3)
+}
+
+// SAdd mocks base method.
+func (m *MockCmdable) 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
 }
 
-// Incr indicates an expected call of Incr.
-func (mr *MockCmdableMockRecorder) Incr(arg0, arg1 interface{}) *gomock.Call {
+// SAdd indicates an expected call of SAdd.
+func (mr *MockCmdableMockRecorder) SAdd(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Incr", reflect.TypeOf((*MockCmdable)(nil).Incr), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockCmdable)(nil).SAdd), varargs...)
 }
 
-// IncrBy mocks base method.
-func (m *MockCmdable) IncrBy(arg0 context.Context, arg1 string, arg2 int64) *redis.IntCmd {
+// SCard mocks base method.
+func (m *MockCmdable) SCard(arg0 context.Context, arg1 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IncrBy", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "SCard", arg0, arg1)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// IncrBy indicates an expected call of IncrBy.
-func (mr *MockCmdableMockRecorder) IncrBy(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SCard indicates an expected call of SCard.
+func (mr *MockCmdableMockRecorder) SCard(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrBy", reflect.TypeOf((*MockCmdable)(nil).IncrBy), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCmdable)(nil).SCard), arg0, arg1)
 }
 
-// IncrByFloat mocks base method.
-func (m *MockCmdable) IncrByFloat(arg0 context.Context, arg1 string, arg2 float64) *redis.FloatCmd {
+// SDiff mocks base method.
+func (m *MockCmdable) SDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "IncrByFloat", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.FloatCmd)
+	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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).SDiff), varargs...)
+}
+
+// SDiffStore mocks base method.
+func (m *MockCmdable) 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
 }
 
-// IncrByFloat indicates an expected call of IncrByFloat.
-func (mr *MockCmdableMockRecorder) IncrByFloat(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SDiffStore indicates an expected call of SDiffStore.
+func (mr *MockCmdableMockRecorder) SDiffStore(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrByFloat", reflect.TypeOf((*MockCmdable)(nil).IncrByFloat), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockCmdable)(nil).SDiffStore), varargs...)
 }
 
-// Info mocks base method.
-func (m *MockCmdable) Info(arg0 context.Context, arg1 ...string) *redis.StringCmd {
+// SInter mocks base method.
+func (m *MockCmdable) SInter(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "Info", varargs...)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "SInter", varargs...)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// Info indicates an expected call of Info.
-func (mr *MockCmdableMockRecorder) Info(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// SInter indicates an expected call of SInter.
+func (mr *MockCmdableMockRecorder) SInter(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Info", reflect.TypeOf((*MockCmdable)(nil).Info), varargs...)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockCmdable)(nil).SInter), varargs...)
 }
 
-// Keys mocks base method.
-func (m *MockCmdable) Keys(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// SInterCard mocks base method.
+func (m *MockCmdable) SInterCard(arg0 context.Context, arg1 int64, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Keys", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	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
 }
 
-// Keys indicates an expected call of Keys.
-func (mr *MockCmdableMockRecorder) Keys(arg0, arg1 interface{}) *gomock.Call {
+// SInterCard indicates an expected call of SInterCard.
+func (mr *MockCmdableMockRecorder) SInterCard(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockCmdable)(nil).Keys), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterCard", reflect.TypeOf((*MockCmdable)(nil).SInterCard), varargs...)
 }
 
-// LIndex mocks base method.
-func (m *MockCmdable) LIndex(arg0 context.Context, arg1 string, arg2 int64) *redis.StringCmd {
+// SInterStore mocks base method.
+func (m *MockCmdable) SInterStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LIndex", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// LIndex indicates an expected call of LIndex.
-func (mr *MockCmdableMockRecorder) LIndex(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SInterStore indicates an expected call of SInterStore.
+func (mr *MockCmdableMockRecorder) SInterStore(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LIndex", reflect.TypeOf((*MockCmdable)(nil).LIndex), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockCmdable)(nil).SInterStore), varargs...)
 }
 
-// LInsert mocks base method.
-func (m *MockCmdable) LInsert(arg0 context.Context, arg1, arg2 string, arg3, arg4 interface{}) *redis.IntCmd {
+// SIsMember mocks base method.
+func (m *MockCmdable) SIsMember(arg0 context.Context, arg1 string, arg2 any) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LInsert", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "SIsMember", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// LInsert indicates an expected call of LInsert.
-func (mr *MockCmdableMockRecorder) LInsert(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// SIsMember indicates an expected call of SIsMember.
+func (mr *MockCmdableMockRecorder) SIsMember(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsert", reflect.TypeOf((*MockCmdable)(nil).LInsert), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCmdable)(nil).SIsMember), arg0, arg1, arg2)
 }
 
-// LInsertAfter mocks base method.
-func (m *MockCmdable) LInsertAfter(arg0 context.Context, arg1 string, arg2, arg3 interface{}) *redis.IntCmd {
+// SMIsMember mocks base method.
+func (m *MockCmdable) SMIsMember(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LInsertAfter", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	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
 }
 
-// LInsertAfter indicates an expected call of LInsertAfter.
-func (mr *MockCmdableMockRecorder) LInsertAfter(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// SMIsMember indicates an expected call of SMIsMember.
+func (mr *MockCmdableMockRecorder) SMIsMember(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertAfter", reflect.TypeOf((*MockCmdable)(nil).LInsertAfter), arg0, arg1, arg2, arg3)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockCmdable)(nil).SMIsMember), varargs...)
 }
 
-// LInsertBefore mocks base method.
-func (m *MockCmdable) LInsertBefore(arg0 context.Context, arg1 string, arg2, arg3 interface{}) *redis.IntCmd {
+// SMembers mocks base method.
+func (m *MockCmdable) SMembers(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LInsertBefore", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "SMembers", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// LInsertBefore indicates an expected call of LInsertBefore.
-func (mr *MockCmdableMockRecorder) LInsertBefore(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// SMembers indicates an expected call of SMembers.
+func (mr *MockCmdableMockRecorder) SMembers(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LInsertBefore", reflect.TypeOf((*MockCmdable)(nil).LInsertBefore), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockCmdable)(nil).SMembers), arg0, arg1)
 }
 
-// LLen mocks base method.
-func (m *MockCmdable) LLen(arg0 context.Context, arg1 string) *redis.IntCmd {
+// SMembersMap mocks base method.
+func (m *MockCmdable) SMembersMap(arg0 context.Context, arg1 string) *redis.StringStructMapCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LLen", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "SMembersMap", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringStructMapCmd)
 	return ret0
 }
 
-// LLen indicates an expected call of LLen.
-func (mr *MockCmdableMockRecorder) LLen(arg0, arg1 interface{}) *gomock.Call {
+// SMembersMap indicates an expected call of SMembersMap.
+func (mr *MockCmdableMockRecorder) SMembersMap(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LLen", reflect.TypeOf((*MockCmdable)(nil).LLen), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockCmdable)(nil).SMembersMap), arg0, arg1)
 }
 
-// LMove mocks base method.
-func (m *MockCmdable) LMove(arg0 context.Context, arg1, arg2, arg3, arg4 string) *redis.StringCmd {
+// SMove mocks base method.
+func (m *MockCmdable) SMove(arg0 context.Context, arg1, arg2 string, arg3 any) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LMove", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "SMove", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// LMove indicates an expected call of LMove.
-func (mr *MockCmdableMockRecorder) LMove(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// SMove indicates an expected call of SMove.
+func (mr *MockCmdableMockRecorder) SMove(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LMove", reflect.TypeOf((*MockCmdable)(nil).LMove), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCmdable)(nil).SMove), arg0, arg1, arg2, arg3)
 }
 
-// LPop mocks base method.
-func (m *MockCmdable) LPop(arg0 context.Context, arg1 string) *redis.StringCmd {
+// SPop mocks base method.
+func (m *MockCmdable) SPop(arg0 context.Context, arg1 string) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LPop", arg0, arg1)
+	ret := m.ctrl.Call(m, "SPop", arg0, arg1)
 	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// LPop indicates an expected call of LPop.
-func (mr *MockCmdableMockRecorder) LPop(arg0, arg1 interface{}) *gomock.Call {
+// SPop indicates an expected call of SPop.
+func (mr *MockCmdableMockRecorder) SPop(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPop", reflect.TypeOf((*MockCmdable)(nil).LPop), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCmdable)(nil).SPop), arg0, arg1)
 }
 
-// LPopCount mocks base method.
-func (m *MockCmdable) LPopCount(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd {
+// SPopN mocks base method.
+func (m *MockCmdable) SPopN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LPopCount", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "SPopN", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// LPopCount indicates an expected call of LPopCount.
-func (mr *MockCmdableMockRecorder) LPopCount(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SPopN indicates an expected call of SPopN.
+func (mr *MockCmdableMockRecorder) SPopN(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPopCount", reflect.TypeOf((*MockCmdable)(nil).LPopCount), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockCmdable)(nil).SPopN), arg0, arg1, arg2)
 }
 
-// LPos mocks base method.
-func (m *MockCmdable) LPos(arg0 context.Context, arg1, arg2 string, arg3 redis.LPosArgs) *redis.IntCmd {
+// SPublish mocks base method.
+func (m *MockCmdable) SPublish(arg0 context.Context, arg1 string, arg2 any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LPos", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "SPublish", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// LPos indicates an expected call of LPos.
-func (mr *MockCmdableMockRecorder) LPos(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// SPublish indicates an expected call of SPublish.
+func (mr *MockCmdableMockRecorder) SPublish(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPos", reflect.TypeOf((*MockCmdable)(nil).LPos), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockCmdable)(nil).SPublish), arg0, arg1, arg2)
 }
 
-// LPosCount mocks base method.
-func (m *MockCmdable) LPosCount(arg0 context.Context, arg1, arg2 string, arg3 int64, arg4 redis.LPosArgs) *redis.IntSliceCmd {
+// SRandMember mocks base method.
+func (m *MockCmdable) SRandMember(arg0 context.Context, arg1 string) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LPosCount", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.IntSliceCmd)
+	ret := m.ctrl.Call(m, "SRandMember", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// LPosCount indicates an expected call of LPosCount.
-func (mr *MockCmdableMockRecorder) LPosCount(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// SRandMember indicates an expected call of SRandMember.
+func (mr *MockCmdableMockRecorder) SRandMember(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPosCount", reflect.TypeOf((*MockCmdable)(nil).LPosCount), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockCmdable)(nil).SRandMember), arg0, arg1)
 }
 
-// LPush mocks base method.
-func (m *MockCmdable) LPush(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// SRandMemberN mocks base method.
+func (m *MockCmdable) SRandMemberN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "LPush", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "SRandMemberN", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// LPush indicates an expected call of LPush.
-func (mr *MockCmdableMockRecorder) LPush(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// SRandMemberN indicates an expected call of SRandMemberN.
+func (mr *MockCmdableMockRecorder) SRandMemberN(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPush", reflect.TypeOf((*MockCmdable)(nil).LPush), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockCmdable)(nil).SRandMemberN), arg0, arg1, arg2)
 }
 
-// LPushX mocks base method.
-func (m *MockCmdable) LPushX(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// SRem mocks base method.
+func (m *MockCmdable) SRem(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "LPushX", varargs...)
+	ret := m.ctrl.Call(m, "SRem", varargs...)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// LPushX indicates an expected call of LPushX.
-func (mr *MockCmdableMockRecorder) LPushX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// SRem indicates an expected call of SRem.
+func (mr *MockCmdableMockRecorder) SRem(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LPushX", reflect.TypeOf((*MockCmdable)(nil).LPushX), varargs...)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockCmdable)(nil).SRem), varargs...)
 }
 
-// LRange mocks base method.
-func (m *MockCmdable) LRange(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StringSliceCmd {
+// SScan mocks base method.
+func (m *MockCmdable) SScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LRange", arg0, arg1, arg2, arg3)
+	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 *MockCmdableMockRecorder) SScan(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCmdable)(nil).SScan), arg0, arg1, arg2, arg3, arg4)
+}
+
+// SUnion mocks base method.
+func (m *MockCmdable) 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
 }
 
-// LRange indicates an expected call of LRange.
-func (mr *MockCmdableMockRecorder) LRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// SUnion indicates an expected call of SUnion.
+func (mr *MockCmdableMockRecorder) SUnion(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRange", reflect.TypeOf((*MockCmdable)(nil).LRange), arg0, arg1, arg2, arg3)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockCmdable)(nil).SUnion), varargs...)
 }
 
-// LRem mocks base method.
-func (m *MockCmdable) LRem(arg0 context.Context, arg1 string, arg2 int64, arg3 interface{}) *redis.IntCmd {
+// SUnionStore mocks base method.
+func (m *MockCmdable) SUnionStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LRem", arg0, arg1, arg2, arg3)
+	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
 }
 
-// LRem indicates an expected call of LRem.
-func (mr *MockCmdableMockRecorder) LRem(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// SUnionStore indicates an expected call of SUnionStore.
+func (mr *MockCmdableMockRecorder) SUnionStore(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LRem", reflect.TypeOf((*MockCmdable)(nil).LRem), arg0, arg1, arg2, arg3)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockCmdable)(nil).SUnionStore), varargs...)
 }
 
-// LSet mocks base method.
-func (m *MockCmdable) LSet(arg0 context.Context, arg1 string, arg2 int64, arg3 interface{}) *redis.StatusCmd {
+// Save mocks base method.
+func (m *MockCmdable) Save(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LSet", arg0, arg1, arg2, arg3)
+	ret := m.ctrl.Call(m, "Save", arg0)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// LSet indicates an expected call of LSet.
-func (mr *MockCmdableMockRecorder) LSet(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// Save indicates an expected call of Save.
+func (mr *MockCmdableMockRecorder) Save(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LSet", reflect.TypeOf((*MockCmdable)(nil).LSet), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCmdable)(nil).Save), arg0)
 }
 
-// LTrim mocks base method.
-func (m *MockCmdable) LTrim(arg0 context.Context, arg1 string, arg2, arg3 int64) *redis.StatusCmd {
+// Scan mocks base method.
+func (m *MockCmdable) Scan(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64) *redis.ScanCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LTrim", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "Scan", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.ScanCmd)
 	return ret0
 }
 
-// LTrim indicates an expected call of LTrim.
-func (mr *MockCmdableMockRecorder) LTrim(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// Scan indicates an expected call of Scan.
+func (mr *MockCmdableMockRecorder) Scan(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LTrim", reflect.TypeOf((*MockCmdable)(nil).LTrim), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockCmdable)(nil).Scan), arg0, arg1, arg2, arg3)
 }
 
-// LastSave mocks base method.
-func (m *MockCmdable) LastSave(arg0 context.Context) *redis.IntCmd {
+// ScanType mocks base method.
+func (m *MockCmdable) ScanType(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64, arg4 string) *redis.ScanCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "LastSave", arg0)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ScanType", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.ScanCmd)
 	return ret0
 }
 
-// LastSave indicates an expected call of LastSave.
-func (mr *MockCmdableMockRecorder) LastSave(arg0 interface{}) *gomock.Call {
+// ScanType indicates an expected call of ScanType.
+func (mr *MockCmdableMockRecorder) ScanType(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LastSave", reflect.TypeOf((*MockCmdable)(nil).LastSave), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockCmdable)(nil).ScanType), arg0, arg1, arg2, arg3, arg4)
 }
 
-// MGet mocks base method.
-func (m *MockCmdable) MGet(arg0 context.Context, arg1 ...string) *redis.SliceCmd {
+// ScriptExists mocks base method.
+func (m *MockCmdable) ScriptExists(arg0 context.Context, arg1 ...string) *redis.BoolSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "MGet", varargs...)
-	ret0, _ := ret[0].(*redis.SliceCmd)
+	ret := m.ctrl.Call(m, "ScriptExists", varargs...)
+	ret0, _ := ret[0].(*redis.BoolSliceCmd)
 	return ret0
 }
 
-// MGet indicates an expected call of MGet.
-func (mr *MockCmdableMockRecorder) MGet(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// ScriptExists indicates an expected call of ScriptExists.
+func (mr *MockCmdableMockRecorder) ScriptExists(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGet", reflect.TypeOf((*MockCmdable)(nil).MGet), varargs...)
+	varargs := append([]any{arg0}, arg1...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockCmdable)(nil).ScriptExists), varargs...)
+}
+
+// ScriptFlush mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ScriptFlush(arg0 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockCmdable)(nil).ScriptFlush), arg0)
 }
 
-// MSet mocks base method.
-func (m *MockCmdable) MSet(arg0 context.Context, arg1 ...interface{}) *redis.StatusCmd {
+// ScriptKill mocks base method.
+func (m *MockCmdable) ScriptKill(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "MSet", varargs...)
+	ret := m.ctrl.Call(m, "ScriptKill", arg0)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// MSet indicates an expected call of MSet.
-func (mr *MockCmdableMockRecorder) MSet(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// ScriptKill indicates an expected call of ScriptKill.
+func (mr *MockCmdableMockRecorder) ScriptKill(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSet", reflect.TypeOf((*MockCmdable)(nil).MSet), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockCmdable)(nil).ScriptKill), arg0)
 }
 
-// MSetNX mocks base method.
-func (m *MockCmdable) MSetNX(arg0 context.Context, arg1 ...interface{}) *redis.BoolCmd {
+// ScriptLoad mocks base method.
+func (m *MockCmdable) ScriptLoad(arg0 context.Context, arg1 string) *redis.StringCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "MSetNX", varargs...)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "ScriptLoad", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringCmd)
 	return ret0
 }
 
-// MSetNX indicates an expected call of MSetNX.
-func (mr *MockCmdableMockRecorder) MSetNX(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// ScriptLoad indicates an expected call of ScriptLoad.
+func (mr *MockCmdableMockRecorder) ScriptLoad(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MSetNX", reflect.TypeOf((*MockCmdable)(nil).MSetNX), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockCmdable)(nil).ScriptLoad), arg0, arg1)
 }
 
-// MemoryUsage mocks base method.
-func (m *MockCmdable) MemoryUsage(arg0 context.Context, arg1 string, arg2 ...int) *redis.IntCmd {
+// Set mocks base method.
+func (m *MockCmdable) Set(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "MemoryUsage", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "Set", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// MemoryUsage indicates an expected call of MemoryUsage.
-func (mr *MockCmdableMockRecorder) MemoryUsage(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// Set indicates an expected call of Set.
+func (mr *MockCmdableMockRecorder) Set(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemoryUsage", reflect.TypeOf((*MockCmdable)(nil).MemoryUsage), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCmdable)(nil).Set), arg0, arg1, arg2, arg3)
 }
 
-// Migrate mocks base method.
-func (m *MockCmdable) Migrate(arg0 context.Context, arg1, arg2, arg3 string, arg4 int, arg5 time.Duration) *redis.StatusCmd {
+// SetArgs mocks base method.
+func (m *MockCmdable) SetArgs(arg0 context.Context, arg1 string, arg2 any, arg3 redis.SetArgs) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Migrate", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret := m.ctrl.Call(m, "SetArgs", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Migrate indicates an expected call of Migrate.
-func (mr *MockCmdableMockRecorder) Migrate(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
+// SetArgs indicates an expected call of SetArgs.
+func (mr *MockCmdableMockRecorder) SetArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Migrate", reflect.TypeOf((*MockCmdable)(nil).Migrate), arg0, arg1, arg2, arg3, arg4, arg5)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockCmdable)(nil).SetArgs), arg0, arg1, arg2, arg3)
 }
 
-// Move mocks base method.
-func (m *MockCmdable) Move(arg0 context.Context, arg1 string, arg2 int) *redis.BoolCmd {
+// SetBit mocks base method.
+func (m *MockCmdable) SetBit(arg0 context.Context, arg1 string, arg2 int64, arg3 int) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Move", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "SetBit", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// Move indicates an expected call of Move.
-func (mr *MockCmdableMockRecorder) Move(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SetBit indicates an expected call of SetBit.
+func (mr *MockCmdableMockRecorder) SetBit(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockCmdable)(nil).Move), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockCmdable)(nil).SetBit), arg0, arg1, arg2, arg3)
 }
 
-// ObjectEncoding mocks base method.
-func (m *MockCmdable) ObjectEncoding(arg0 context.Context, arg1 string) *redis.StringCmd {
+// SetEx mocks base method.
+func (m *MockCmdable) SetEx(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ObjectEncoding", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "SetEx", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ObjectEncoding indicates an expected call of ObjectEncoding.
-func (mr *MockCmdableMockRecorder) ObjectEncoding(arg0, arg1 interface{}) *gomock.Call {
+// SetEx indicates an expected call of SetEx.
+func (mr *MockCmdableMockRecorder) SetEx(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectEncoding", reflect.TypeOf((*MockCmdable)(nil).ObjectEncoding), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockCmdable)(nil).SetEx), arg0, arg1, arg2, arg3)
 }
 
-// ObjectIdleTime mocks base method.
-func (m *MockCmdable) ObjectIdleTime(arg0 context.Context, arg1 string) *redis.DurationCmd {
+// SetNX mocks base method.
+func (m *MockCmdable) SetNX(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ObjectIdleTime", arg0, arg1)
-	ret0, _ := ret[0].(*redis.DurationCmd)
+	ret := m.ctrl.Call(m, "SetNX", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// ObjectIdleTime indicates an expected call of ObjectIdleTime.
-func (mr *MockCmdableMockRecorder) ObjectIdleTime(arg0, arg1 interface{}) *gomock.Call {
+// SetNX indicates an expected call of SetNX.
+func (mr *MockCmdableMockRecorder) SetNX(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectIdleTime", reflect.TypeOf((*MockCmdable)(nil).ObjectIdleTime), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockCmdable)(nil).SetNX), arg0, arg1, arg2, arg3)
 }
 
-// ObjectRefCount mocks base method.
-func (m *MockCmdable) ObjectRefCount(arg0 context.Context, arg1 string) *redis.IntCmd {
+// SetRange mocks base method.
+func (m *MockCmdable) SetRange(arg0 context.Context, arg1 string, arg2 int64, arg3 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ObjectRefCount", arg0, arg1)
+	ret := m.ctrl.Call(m, "SetRange", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// ObjectRefCount indicates an expected call of ObjectRefCount.
-func (mr *MockCmdableMockRecorder) ObjectRefCount(arg0, arg1 interface{}) *gomock.Call {
+// SetRange indicates an expected call of SetRange.
+func (mr *MockCmdableMockRecorder) SetRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObjectRefCount", reflect.TypeOf((*MockCmdable)(nil).ObjectRefCount), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockCmdable)(nil).SetRange), arg0, arg1, arg2, arg3)
 }
 
-// PExpire mocks base method.
-func (m *MockCmdable) PExpire(arg0 context.Context, arg1 string, arg2 time.Duration) *redis.BoolCmd {
+// SetXX mocks base method.
+func (m *MockCmdable) SetXX(arg0 context.Context, arg1 string, arg2 any, arg3 time.Duration) *redis.BoolCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PExpire", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "SetXX", arg0, arg1, arg2, arg3)
 	ret0, _ := ret[0].(*redis.BoolCmd)
 	return ret0
 }
 
-// PExpire indicates an expected call of PExpire.
-func (mr *MockCmdableMockRecorder) PExpire(arg0, arg1, arg2 interface{}) *gomock.Call {
+// SetXX indicates an expected call of SetXX.
+func (mr *MockCmdableMockRecorder) SetXX(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpire", reflect.TypeOf((*MockCmdable)(nil).PExpire), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockCmdable)(nil).SetXX), arg0, arg1, arg2, arg3)
 }
 
-// PExpireAt mocks base method.
-func (m *MockCmdable) PExpireAt(arg0 context.Context, arg1 string, arg2 time.Time) *redis.BoolCmd {
+// Shutdown mocks base method.
+func (m *MockCmdable) Shutdown(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PExpireAt", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "Shutdown", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// PExpireAt indicates an expected call of PExpireAt.
-func (mr *MockCmdableMockRecorder) PExpireAt(arg0, arg1, arg2 interface{}) *gomock.Call {
+// Shutdown indicates an expected call of Shutdown.
+func (mr *MockCmdableMockRecorder) Shutdown(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PExpireAt", reflect.TypeOf((*MockCmdable)(nil).PExpireAt), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockCmdable)(nil).Shutdown), arg0)
 }
 
-// PFAdd mocks base method.
-func (m *MockCmdable) PFAdd(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// ShutdownNoSave mocks base method.
+func (m *MockCmdable) ShutdownNoSave(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PFAdd", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ShutdownNoSave", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// PFAdd indicates an expected call of PFAdd.
-func (mr *MockCmdableMockRecorder) PFAdd(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// ShutdownNoSave indicates an expected call of ShutdownNoSave.
+func (mr *MockCmdableMockRecorder) ShutdownNoSave(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFAdd", reflect.TypeOf((*MockCmdable)(nil).PFAdd), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownNoSave), arg0)
 }
 
-// PFCount mocks base method.
-func (m *MockCmdable) PFCount(arg0 context.Context, arg1 ...string) *redis.IntCmd {
+// ShutdownSave mocks base method.
+func (m *MockCmdable) ShutdownSave(arg0 context.Context) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PFCount", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "ShutdownSave", arg0)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// PFCount indicates an expected call of PFCount.
-func (mr *MockCmdableMockRecorder) PFCount(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// ShutdownSave indicates an expected call of ShutdownSave.
+func (mr *MockCmdableMockRecorder) ShutdownSave(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFCount", reflect.TypeOf((*MockCmdable)(nil).PFCount), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownSave), arg0)
 }
 
-// PFMerge mocks base method.
-func (m *MockCmdable) PFMerge(arg0 context.Context, arg1 string, arg2 ...string) *redis.StatusCmd {
+// SlaveOf mocks base method.
+func (m *MockCmdable) SlaveOf(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "PFMerge", varargs...)
+	ret := m.ctrl.Call(m, "SlaveOf", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// PFMerge indicates an expected call of PFMerge.
-func (mr *MockCmdableMockRecorder) PFMerge(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// SlaveOf indicates an expected call of SlaveOf.
+func (mr *MockCmdableMockRecorder) SlaveOf(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PFMerge", reflect.TypeOf((*MockCmdable)(nil).PFMerge), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockCmdable)(nil).SlaveOf), arg0, arg1, arg2)
 }
 
-// PTTL mocks base method.
-func (m *MockCmdable) PTTL(arg0 context.Context, arg1 string) *redis.DurationCmd {
+// SlowLogGet mocks base method.
+func (m *MockCmdable) SlowLogGet(arg0 context.Context, arg1 int64) *redis.SlowLogCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PTTL", arg0, arg1)
-	ret0, _ := ret[0].(*redis.DurationCmd)
+	ret := m.ctrl.Call(m, "SlowLogGet", arg0, arg1)
+	ret0, _ := ret[0].(*redis.SlowLogCmd)
 	return ret0
 }
 
-// PTTL indicates an expected call of PTTL.
-func (mr *MockCmdableMockRecorder) PTTL(arg0, arg1 interface{}) *gomock.Call {
+// SlowLogGet indicates an expected call of SlowLogGet.
+func (mr *MockCmdableMockRecorder) SlowLogGet(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PTTL", reflect.TypeOf((*MockCmdable)(nil).PTTL), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockCmdable)(nil).SlowLogGet), arg0, arg1)
 }
 
-// Persist mocks base method.
-func (m *MockCmdable) Persist(arg0 context.Context, arg1 string) *redis.BoolCmd {
+// Sort mocks base method.
+func (m *MockCmdable) Sort(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Persist", arg0, arg1)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "Sort", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// Persist indicates an expected call of Persist.
-func (mr *MockCmdableMockRecorder) Persist(arg0, arg1 interface{}) *gomock.Call {
+// Sort indicates an expected call of Sort.
+func (mr *MockCmdableMockRecorder) Sort(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Persist", reflect.TypeOf((*MockCmdable)(nil).Persist), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockCmdable)(nil).Sort), arg0, arg1, arg2)
 }
 
-// Ping mocks base method.
-func (m *MockCmdable) Ping(arg0 context.Context) *redis.StatusCmd {
+// SortInterfaces mocks base method.
+func (m *MockCmdable) SortInterfaces(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.SliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Ping", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "SortInterfaces", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.SliceCmd)
 	return ret0
 }
 
-// Ping indicates an expected call of Ping.
-func (mr *MockCmdableMockRecorder) Ping(arg0 interface{}) *gomock.Call {
+// SortInterfaces indicates an expected call of SortInterfaces.
+func (mr *MockCmdableMockRecorder) SortInterfaces(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockCmdable)(nil).Ping), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockCmdable)(nil).SortInterfaces), arg0, arg1, arg2)
 }
 
-// Pipeline mocks base method.
-func (m *MockCmdable) Pipeline() redis.Pipeliner {
+// SortRO mocks base method.
+func (m *MockCmdable) SortRO(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Pipeline")
-	ret0, _ := ret[0].(redis.Pipeliner)
+	ret := m.ctrl.Call(m, "SortRO", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// Pipeline indicates an expected call of Pipeline.
-func (mr *MockCmdableMockRecorder) Pipeline() *gomock.Call {
+// SortRO indicates an expected call of SortRO.
+func (mr *MockCmdableMockRecorder) SortRO(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipeline", reflect.TypeOf((*MockCmdable)(nil).Pipeline))
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortRO", reflect.TypeOf((*MockCmdable)(nil).SortRO), arg0, arg1, arg2)
 }
 
-// Pipelined mocks base method.
-func (m *MockCmdable) Pipelined(arg0 context.Context, arg1 func(redis.Pipeliner) error) ([]redis.Cmder, error) {
+// SortStore mocks base method.
+func (m *MockCmdable) SortStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.Sort) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Pipelined", arg0, arg1)
-	ret0, _ := ret[0].([]redis.Cmder)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
+	ret := m.ctrl.Call(m, "SortStore", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.IntCmd)
+	return ret0
 }
 
-// Pipelined indicates an expected call of Pipelined.
-func (mr *MockCmdableMockRecorder) Pipelined(arg0, arg1 interface{}) *gomock.Call {
+// SortStore indicates an expected call of SortStore.
+func (mr *MockCmdableMockRecorder) SortStore(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Pipelined", reflect.TypeOf((*MockCmdable)(nil).Pipelined), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockCmdable)(nil).SortStore), arg0, arg1, arg2, arg3)
 }
 
-// PubSubChannels mocks base method.
-func (m *MockCmdable) PubSubChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// StrLen mocks base method.
+func (m *MockCmdable) StrLen(arg0 context.Context, arg1 string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PubSubChannels", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "StrLen", arg0, arg1)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// PubSubChannels indicates an expected call of PubSubChannels.
-func (mr *MockCmdableMockRecorder) PubSubChannels(arg0, arg1 interface{}) *gomock.Call {
+// StrLen indicates an expected call of StrLen.
+func (mr *MockCmdableMockRecorder) StrLen(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubChannels), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCmdable)(nil).StrLen), arg0, arg1)
 }
 
-// PubSubNumPat mocks base method.
-func (m *MockCmdable) PubSubNumPat(arg0 context.Context) *redis.IntCmd {
+// TDigestAdd mocks base method.
+func (m *MockCmdable) TDigestAdd(arg0 context.Context, arg1 string, arg2 ...float64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PubSubNumPat", arg0)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	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
 }
 
-// PubSubNumPat indicates an expected call of PubSubNumPat.
-func (mr *MockCmdableMockRecorder) PubSubNumPat(arg0 interface{}) *gomock.Call {
+// TDigestAdd indicates an expected call of TDigestAdd.
+func (mr *MockCmdableMockRecorder) TDigestAdd(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumPat", reflect.TypeOf((*MockCmdable)(nil).PubSubNumPat), arg0)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestAdd", reflect.TypeOf((*MockCmdable)(nil).TDigestAdd), varargs...)
 }
 
-// PubSubNumSub mocks base method.
-func (m *MockCmdable) PubSubNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd {
+// TDigestByRank mocks base method.
+func (m *MockCmdable) TDigestByRank(arg0 context.Context, arg1 string, arg2 ...uint64) *redis.FloatSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
+	varargs := []any{arg0, arg1}
+	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "PubSubNumSub", varargs...)
-	ret0, _ := ret[0].(*redis.MapStringIntCmd)
+	ret := m.ctrl.Call(m, "TDigestByRank", varargs...)
+	ret0, _ := ret[0].(*redis.FloatSliceCmd)
 	return ret0
 }
 
-// PubSubNumSub indicates an expected call of PubSubNumSub.
-func (mr *MockCmdableMockRecorder) PubSubNumSub(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// TDigestByRank indicates an expected call of TDigestByRank.
+func (mr *MockCmdableMockRecorder) TDigestByRank(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubNumSub), varargs...)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRank", reflect.TypeOf((*MockCmdable)(nil).TDigestByRank), varargs...)
 }
 
-// PubSubShardChannels mocks base method.
-func (m *MockCmdable) PubSubShardChannels(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// TDigestByRevRank mocks base method.
+func (m *MockCmdable) TDigestByRevRank(arg0 context.Context, arg1 string, arg2 ...uint64) *redis.FloatSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "PubSubShardChannels", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	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
 }
 
-// PubSubShardChannels indicates an expected call of PubSubShardChannels.
-func (mr *MockCmdableMockRecorder) PubSubShardChannels(arg0, arg1 interface{}) *gomock.Call {
+// TDigestByRevRank indicates an expected call of TDigestByRevRank.
+func (mr *MockCmdableMockRecorder) TDigestByRevRank(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardChannels", reflect.TypeOf((*MockCmdable)(nil).PubSubShardChannels), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestByRevRank", reflect.TypeOf((*MockCmdable)(nil).TDigestByRevRank), varargs...)
 }
 
-// PubSubShardNumSub mocks base method.
-func (m *MockCmdable) PubSubShardNumSub(arg0 context.Context, arg1 ...string) *redis.MapStringIntCmd {
+// TDigestCDF mocks base method.
+func (m *MockCmdable) TDigestCDF(arg0 context.Context, arg1 string, arg2 ...float64) *redis.FloatSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
+	varargs := []any{arg0, arg1}
+	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "PubSubShardNumSub", varargs...)
-	ret0, _ := ret[0].(*redis.MapStringIntCmd)
+	ret := m.ctrl.Call(m, "TDigestCDF", varargs...)
+	ret0, _ := ret[0].(*redis.FloatSliceCmd)
 	return ret0
 }
 
-// PubSubShardNumSub indicates an expected call of PubSubShardNumSub.
-func (mr *MockCmdableMockRecorder) PubSubShardNumSub(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// TDigestCDF indicates an expected call of TDigestCDF.
+func (mr *MockCmdableMockRecorder) TDigestCDF(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PubSubShardNumSub", reflect.TypeOf((*MockCmdable)(nil).PubSubShardNumSub), varargs...)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCDF", reflect.TypeOf((*MockCmdable)(nil).TDigestCDF), varargs...)
 }
 
-// Publish mocks base method.
-func (m *MockCmdable) Publish(arg0 context.Context, arg1 string, arg2 interface{}) *redis.IntCmd {
+// TDigestCreate mocks base method.
+func (m *MockCmdable) TDigestCreate(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Publish", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TDigestCreate", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Publish indicates an expected call of Publish.
-func (mr *MockCmdableMockRecorder) Publish(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TDigestCreate indicates an expected call of TDigestCreate.
+func (mr *MockCmdableMockRecorder) TDigestCreate(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Publish", reflect.TypeOf((*MockCmdable)(nil).Publish), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreate", reflect.TypeOf((*MockCmdable)(nil).TDigestCreate), arg0, arg1)
 }
 
-// Quit mocks base method.
-func (m *MockCmdable) Quit(arg0 context.Context) *redis.StatusCmd {
+// TDigestCreateWithCompression mocks base method.
+func (m *MockCmdable) TDigestCreateWithCompression(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Quit", arg0)
+	ret := m.ctrl.Call(m, "TDigestCreateWithCompression", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Quit indicates an expected call of Quit.
-func (mr *MockCmdableMockRecorder) Quit(arg0 interface{}) *gomock.Call {
+// TDigestCreateWithCompression indicates an expected call of TDigestCreateWithCompression.
+func (mr *MockCmdableMockRecorder) TDigestCreateWithCompression(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Quit", reflect.TypeOf((*MockCmdable)(nil).Quit), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestCreateWithCompression", reflect.TypeOf((*MockCmdable)(nil).TDigestCreateWithCompression), arg0, arg1, arg2)
 }
 
-// RPop mocks base method.
-func (m *MockCmdable) RPop(arg0 context.Context, arg1 string) *redis.StringCmd {
+// TDigestInfo mocks base method.
+func (m *MockCmdable) TDigestInfo(arg0 context.Context, arg1 string) *redis.TDigestInfoCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RPop", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "TDigestInfo", arg0, arg1)
+	ret0, _ := ret[0].(*redis.TDigestInfoCmd)
 	return ret0
 }
 
-// RPop indicates an expected call of RPop.
-func (mr *MockCmdableMockRecorder) RPop(arg0, arg1 interface{}) *gomock.Call {
+// TDigestInfo indicates an expected call of TDigestInfo.
+func (mr *MockCmdableMockRecorder) TDigestInfo(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPop", reflect.TypeOf((*MockCmdable)(nil).RPop), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestInfo", reflect.TypeOf((*MockCmdable)(nil).TDigestInfo), arg0, arg1)
 }
 
-// RPopCount mocks base method.
-func (m *MockCmdable) RPopCount(arg0 context.Context, arg1 string, arg2 int) *redis.StringSliceCmd {
+// TDigestMax mocks base method.
+func (m *MockCmdable) TDigestMax(arg0 context.Context, arg1 string) *redis.FloatCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RPopCount", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "TDigestMax", arg0, arg1)
+	ret0, _ := ret[0].(*redis.FloatCmd)
 	return ret0
 }
 
-// RPopCount indicates an expected call of RPopCount.
-func (mr *MockCmdableMockRecorder) RPopCount(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TDigestMax indicates an expected call of TDigestMax.
+func (mr *MockCmdableMockRecorder) TDigestMax(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopCount", reflect.TypeOf((*MockCmdable)(nil).RPopCount), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMax", reflect.TypeOf((*MockCmdable)(nil).TDigestMax), arg0, arg1)
 }
 
-// RPopLPush mocks base method.
-func (m *MockCmdable) RPopLPush(arg0 context.Context, arg1, arg2 string) *redis.StringCmd {
+// TDigestMerge mocks base method.
+func (m *MockCmdable) TDigestMerge(arg0 context.Context, arg1 string, arg2 *redis.TDigestMergeOptions, arg3 ...string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RPopLPush", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// RPopLPush indicates an expected call of RPopLPush.
-func (mr *MockCmdableMockRecorder) RPopLPush(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TDigestMerge indicates an expected call of TDigestMerge.
+func (mr *MockCmdableMockRecorder) TDigestMerge(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPopLPush", reflect.TypeOf((*MockCmdable)(nil).RPopLPush), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMerge", reflect.TypeOf((*MockCmdable)(nil).TDigestMerge), varargs...)
 }
 
-// RPush mocks base method.
-func (m *MockCmdable) RPush(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// TDigestMin mocks base method.
+func (m *MockCmdable) TDigestMin(arg0 context.Context, arg1 string) *redis.FloatCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "RPush", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TDigestMin", arg0, arg1)
+	ret0, _ := ret[0].(*redis.FloatCmd)
 	return ret0
 }
 
-// RPush indicates an expected call of RPush.
-func (mr *MockCmdableMockRecorder) RPush(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TDigestMin indicates an expected call of TDigestMin.
+func (mr *MockCmdableMockRecorder) TDigestMin(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPush", reflect.TypeOf((*MockCmdable)(nil).RPush), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestMin", reflect.TypeOf((*MockCmdable)(nil).TDigestMin), arg0, arg1)
 }
 
-// RPushX mocks base method.
-func (m *MockCmdable) RPushX(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// TDigestQuantile mocks base method.
+func (m *MockCmdable) TDigestQuantile(arg0 context.Context, arg1 string, arg2 ...float64) *redis.FloatSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
-	ret := m.ctrl.Call(m, "RPushX", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TDigestQuantile", varargs...)
+	ret0, _ := ret[0].(*redis.FloatSliceCmd)
 	return ret0
 }
 
-// RPushX indicates an expected call of RPushX.
-func (mr *MockCmdableMockRecorder) RPushX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TDigestQuantile indicates an expected call of TDigestQuantile.
+func (mr *MockCmdableMockRecorder) TDigestQuantile(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RPushX", reflect.TypeOf((*MockCmdable)(nil).RPushX), varargs...)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestQuantile", reflect.TypeOf((*MockCmdable)(nil).TDigestQuantile), varargs...)
 }
 
-// RandomKey mocks base method.
-func (m *MockCmdable) RandomKey(arg0 context.Context) *redis.StringCmd {
+// TDigestRank mocks base method.
+func (m *MockCmdable) TDigestRank(arg0 context.Context, arg1 string, arg2 ...float64) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RandomKey", arg0)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	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
 }
 
-// RandomKey indicates an expected call of RandomKey.
-func (mr *MockCmdableMockRecorder) RandomKey(arg0 interface{}) *gomock.Call {
+// TDigestRank indicates an expected call of TDigestRank.
+func (mr *MockCmdableMockRecorder) TDigestRank(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandomKey", reflect.TypeOf((*MockCmdable)(nil).RandomKey), arg0)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRank", reflect.TypeOf((*MockCmdable)(nil).TDigestRank), varargs...)
 }
 
-// ReadOnly mocks base method.
-func (m *MockCmdable) ReadOnly(arg0 context.Context) *redis.StatusCmd {
+// TDigestReset mocks base method.
+func (m *MockCmdable) TDigestReset(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReadOnly", arg0)
+	ret := m.ctrl.Call(m, "TDigestReset", arg0, arg1)
 	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// ReadOnly indicates an expected call of ReadOnly.
-func (mr *MockCmdableMockRecorder) ReadOnly(arg0 interface{}) *gomock.Call {
+// TDigestReset indicates an expected call of TDigestReset.
+func (mr *MockCmdableMockRecorder) TDigestReset(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockCmdable)(nil).ReadOnly), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestReset", reflect.TypeOf((*MockCmdable)(nil).TDigestReset), arg0, arg1)
 }
 
-// ReadWrite mocks base method.
-func (m *MockCmdable) ReadWrite(arg0 context.Context) *redis.StatusCmd {
+// TDigestRevRank mocks base method.
+func (m *MockCmdable) TDigestRevRank(arg0 context.Context, arg1 string, arg2 ...float64) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ReadWrite", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	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
 }
 
-// ReadWrite indicates an expected call of ReadWrite.
-func (mr *MockCmdableMockRecorder) ReadWrite(arg0 interface{}) *gomock.Call {
+// TDigestRevRank indicates an expected call of TDigestRevRank.
+func (mr *MockCmdableMockRecorder) TDigestRevRank(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadWrite", reflect.TypeOf((*MockCmdable)(nil).ReadWrite), arg0)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestRevRank", reflect.TypeOf((*MockCmdable)(nil).TDigestRevRank), varargs...)
 }
 
-// Rename mocks base method.
-func (m *MockCmdable) Rename(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
+// TDigestTrimmedMean mocks base method.
+func (m *MockCmdable) TDigestTrimmedMean(arg0 context.Context, arg1 string, arg2, arg3 float64) *redis.FloatCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Rename", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TDigestTrimmedMean", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.FloatCmd)
 	return ret0
 }
 
-// Rename indicates an expected call of Rename.
-func (mr *MockCmdableMockRecorder) Rename(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TDigestTrimmedMean indicates an expected call of TDigestTrimmedMean.
+func (mr *MockCmdableMockRecorder) TDigestTrimmedMean(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Rename", reflect.TypeOf((*MockCmdable)(nil).Rename), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TDigestTrimmedMean", reflect.TypeOf((*MockCmdable)(nil).TDigestTrimmedMean), arg0, arg1, arg2, arg3)
 }
 
-// RenameNX mocks base method.
-func (m *MockCmdable) RenameNX(arg0 context.Context, arg1, arg2 string) *redis.BoolCmd {
+// TFCall mocks base method.
+func (m *MockCmdable) TFCall(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.Cmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RenameNX", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "TFCall", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.Cmd)
 	return ret0
 }
 
-// RenameNX indicates an expected call of RenameNX.
-func (mr *MockCmdableMockRecorder) RenameNX(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TFCall indicates an expected call of TFCall.
+func (mr *MockCmdableMockRecorder) TFCall(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenameNX", reflect.TypeOf((*MockCmdable)(nil).RenameNX), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCall", reflect.TypeOf((*MockCmdable)(nil).TFCall), arg0, arg1, arg2, arg3)
 }
 
-// Restore mocks base method.
-func (m *MockCmdable) Restore(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd {
+// TFCallASYNC mocks base method.
+func (m *MockCmdable) TFCallASYNC(arg0 context.Context, arg1, arg2 string, arg3 int) *redis.Cmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Restore", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TFCallASYNC", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.Cmd)
 	return ret0
 }
 
-// Restore indicates an expected call of Restore.
-func (mr *MockCmdableMockRecorder) Restore(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TFCallASYNC indicates an expected call of TFCallASYNC.
+func (mr *MockCmdableMockRecorder) TFCallASYNC(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Restore", reflect.TypeOf((*MockCmdable)(nil).Restore), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNC", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNC), arg0, arg1, arg2, arg3)
 }
 
-// RestoreReplace mocks base method.
-func (m *MockCmdable) RestoreReplace(arg0 context.Context, arg1 string, arg2 time.Duration, arg3 string) *redis.StatusCmd {
+// TFCallASYNCArgs mocks base method.
+func (m *MockCmdable) TFCallASYNCArgs(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 *redis.TFCallOptions) *redis.Cmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "RestoreReplace", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TFCallASYNCArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.Cmd)
 	return ret0
 }
 
-// RestoreReplace indicates an expected call of RestoreReplace.
-func (mr *MockCmdableMockRecorder) RestoreReplace(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TFCallASYNCArgs indicates an expected call of TFCallASYNCArgs.
+func (mr *MockCmdableMockRecorder) TFCallASYNCArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreReplace", reflect.TypeOf((*MockCmdable)(nil).RestoreReplace), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallASYNCArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallASYNCArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SAdd mocks base method.
-func (m *MockCmdable) SAdd(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// TFCallArgs mocks base method.
+func (m *MockCmdable) TFCallArgs(arg0 context.Context, arg1, arg2 string, arg3 int, arg4 *redis.TFCallOptions) *redis.Cmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SAdd", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TFCallArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.Cmd)
 	return ret0
 }
 
-// SAdd indicates an expected call of SAdd.
-func (mr *MockCmdableMockRecorder) SAdd(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TFCallArgs indicates an expected call of TFCallArgs.
+func (mr *MockCmdableMockRecorder) TFCallArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SAdd", reflect.TypeOf((*MockCmdable)(nil).SAdd), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFCallArgs", reflect.TypeOf((*MockCmdable)(nil).TFCallArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SCard mocks base method.
-func (m *MockCmdable) SCard(arg0 context.Context, arg1 string) *redis.IntCmd {
+// TFunctionDelete mocks base method.
+func (m *MockCmdable) TFunctionDelete(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SCard", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TFunctionDelete", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SCard indicates an expected call of SCard.
-func (mr *MockCmdableMockRecorder) SCard(arg0, arg1 interface{}) *gomock.Call {
+// TFunctionDelete indicates an expected call of TFunctionDelete.
+func (mr *MockCmdableMockRecorder) TFunctionDelete(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SCard", reflect.TypeOf((*MockCmdable)(nil).SCard), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionDelete", reflect.TypeOf((*MockCmdable)(nil).TFunctionDelete), arg0, arg1)
 }
 
-// SDiff mocks base method.
-func (m *MockCmdable) SDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd {
+// TFunctionList mocks base method.
+func (m *MockCmdable) TFunctionList(arg0 context.Context) *redis.MapStringInterfaceSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SDiff", varargs...)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "TFunctionList", arg0)
+	ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd)
 	return ret0
 }
 
-// SDiff indicates an expected call of SDiff.
-func (mr *MockCmdableMockRecorder) SDiff(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// TFunctionList indicates an expected call of TFunctionList.
+func (mr *MockCmdableMockRecorder) TFunctionList(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiff", reflect.TypeOf((*MockCmdable)(nil).SDiff), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionList", reflect.TypeOf((*MockCmdable)(nil).TFunctionList), arg0)
 }
 
-// SDiffStore mocks base method.
-func (m *MockCmdable) SDiffStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
+// TFunctionListArgs mocks base method.
+func (m *MockCmdable) TFunctionListArgs(arg0 context.Context, arg1 *redis.TFunctionListOptions) *redis.MapStringInterfaceSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SDiffStore", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TFunctionListArgs", arg0, arg1)
+	ret0, _ := ret[0].(*redis.MapStringInterfaceSliceCmd)
 	return ret0
 }
 
-// SDiffStore indicates an expected call of SDiffStore.
-func (mr *MockCmdableMockRecorder) SDiffStore(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TFunctionListArgs indicates an expected call of TFunctionListArgs.
+func (mr *MockCmdableMockRecorder) TFunctionListArgs(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SDiffStore", reflect.TypeOf((*MockCmdable)(nil).SDiffStore), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionListArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionListArgs), arg0, arg1)
 }
 
-// SInter mocks base method.
-func (m *MockCmdable) SInter(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd {
+// TFunctionLoad mocks base method.
+func (m *MockCmdable) TFunctionLoad(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SInter", varargs...)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "TFunctionLoad", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SInter indicates an expected call of SInter.
-func (mr *MockCmdableMockRecorder) SInter(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// TFunctionLoad indicates an expected call of TFunctionLoad.
+func (mr *MockCmdableMockRecorder) TFunctionLoad(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInter", reflect.TypeOf((*MockCmdable)(nil).SInter), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoad", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoad), arg0, arg1)
 }
 
-// SInterStore mocks base method.
-func (m *MockCmdable) SInterStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
+// TFunctionLoadArgs mocks base method.
+func (m *MockCmdable) TFunctionLoadArgs(arg0 context.Context, arg1 string, arg2 *redis.TFunctionLoadOptions) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SInterStore", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TFunctionLoadArgs", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SInterStore indicates an expected call of SInterStore.
-func (mr *MockCmdableMockRecorder) SInterStore(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TFunctionLoadArgs indicates an expected call of TFunctionLoadArgs.
+func (mr *MockCmdableMockRecorder) TFunctionLoadArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SInterStore", reflect.TypeOf((*MockCmdable)(nil).SInterStore), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TFunctionLoadArgs", reflect.TypeOf((*MockCmdable)(nil).TFunctionLoadArgs), arg0, arg1, arg2)
 }
 
-// SIsMember mocks base method.
-func (m *MockCmdable) SIsMember(arg0 context.Context, arg1 string, arg2 interface{}) *redis.BoolCmd {
+// TSAdd mocks base method.
+func (m *MockCmdable) TSAdd(arg0 context.Context, arg1 string, arg2 any, arg3 float64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SIsMember", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "TSAdd", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// SIsMember indicates an expected call of SIsMember.
-func (mr *MockCmdableMockRecorder) SIsMember(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TSAdd indicates an expected call of TSAdd.
+func (mr *MockCmdableMockRecorder) TSAdd(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SIsMember", reflect.TypeOf((*MockCmdable)(nil).SIsMember), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAdd", reflect.TypeOf((*MockCmdable)(nil).TSAdd), arg0, arg1, arg2, arg3)
 }
 
-// SMIsMember mocks base method.
-func (m *MockCmdable) SMIsMember(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.BoolSliceCmd {
+// TSAddWithArgs mocks base method.
+func (m *MockCmdable) TSAddWithArgs(arg0 context.Context, arg1 string, arg2 any, arg3 float64, arg4 *redis.TSOptions) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SMIsMember", varargs...)
-	ret0, _ := ret[0].(*redis.BoolSliceCmd)
+	ret := m.ctrl.Call(m, "TSAddWithArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// SMIsMember indicates an expected call of SMIsMember.
-func (mr *MockCmdableMockRecorder) SMIsMember(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TSAddWithArgs indicates an expected call of TSAddWithArgs.
+func (mr *MockCmdableMockRecorder) TSAddWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMIsMember", reflect.TypeOf((*MockCmdable)(nil).SMIsMember), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAddWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSAddWithArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SMembers mocks base method.
-func (m *MockCmdable) SMembers(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
+// TSAlter mocks base method.
+func (m *MockCmdable) TSAlter(arg0 context.Context, arg1 string, arg2 *redis.TSAlterOptions) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SMembers", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "TSAlter", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SMembers indicates an expected call of SMembers.
-func (mr *MockCmdableMockRecorder) SMembers(arg0, arg1 interface{}) *gomock.Call {
+// TSAlter indicates an expected call of TSAlter.
+func (mr *MockCmdableMockRecorder) TSAlter(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembers", reflect.TypeOf((*MockCmdable)(nil).SMembers), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSAlter", reflect.TypeOf((*MockCmdable)(nil).TSAlter), arg0, arg1, arg2)
 }
 
-// SMembersMap mocks base method.
-func (m *MockCmdable) SMembersMap(arg0 context.Context, arg1 string) *redis.StringStructMapCmd {
+// TSCreate mocks base method.
+func (m *MockCmdable) TSCreate(arg0 context.Context, arg1 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SMembersMap", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringStructMapCmd)
+	ret := m.ctrl.Call(m, "TSCreate", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SMembersMap indicates an expected call of SMembersMap.
-func (mr *MockCmdableMockRecorder) SMembersMap(arg0, arg1 interface{}) *gomock.Call {
+// TSCreate indicates an expected call of TSCreate.
+func (mr *MockCmdableMockRecorder) TSCreate(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMembersMap", reflect.TypeOf((*MockCmdable)(nil).SMembersMap), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreate", reflect.TypeOf((*MockCmdable)(nil).TSCreate), arg0, arg1)
 }
 
-// SMove mocks base method.
-func (m *MockCmdable) SMove(arg0 context.Context, arg1, arg2 string, arg3 interface{}) *redis.BoolCmd {
+// TSCreateRule mocks base method.
+func (m *MockCmdable) TSCreateRule(arg0 context.Context, arg1, arg2 string, arg3 redis.Aggregator, arg4 int) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SMove", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "TSCreateRule", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SMove indicates an expected call of SMove.
-func (mr *MockCmdableMockRecorder) SMove(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSCreateRule indicates an expected call of TSCreateRule.
+func (mr *MockCmdableMockRecorder) TSCreateRule(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SMove", reflect.TypeOf((*MockCmdable)(nil).SMove), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRule", reflect.TypeOf((*MockCmdable)(nil).TSCreateRule), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SPop mocks base method.
-func (m *MockCmdable) SPop(arg0 context.Context, arg1 string) *redis.StringCmd {
+// TSCreateRuleWithArgs mocks base method.
+func (m *MockCmdable) 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, "SPop", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "TSCreateRuleWithArgs", arg0, arg1, arg2, arg3, arg4, arg5)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SPop indicates an expected call of SPop.
-func (mr *MockCmdableMockRecorder) SPop(arg0, arg1 interface{}) *gomock.Call {
+// TSCreateRuleWithArgs indicates an expected call of TSCreateRuleWithArgs.
+func (mr *MockCmdableMockRecorder) TSCreateRuleWithArgs(arg0, arg1, arg2, arg3, arg4, arg5 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPop", reflect.TypeOf((*MockCmdable)(nil).SPop), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateRuleWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSCreateRuleWithArgs), arg0, arg1, arg2, arg3, arg4, arg5)
 }
 
-// SPopN mocks base method.
-func (m *MockCmdable) SPopN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd {
+// TSCreateWithArgs mocks base method.
+func (m *MockCmdable) TSCreateWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSOptions) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SPopN", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "TSCreateWithArgs", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SPopN indicates an expected call of SPopN.
-func (mr *MockCmdableMockRecorder) SPopN(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TSCreateWithArgs indicates an expected call of TSCreateWithArgs.
+func (mr *MockCmdableMockRecorder) TSCreateWithArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPopN", reflect.TypeOf((*MockCmdable)(nil).SPopN), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSCreateWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSCreateWithArgs), arg0, arg1, arg2)
 }
 
-// SPublish mocks base method.
-func (m *MockCmdable) SPublish(arg0 context.Context, arg1 string, arg2 interface{}) *redis.IntCmd {
+// TSDecrBy mocks base method.
+func (m *MockCmdable) TSDecrBy(arg0 context.Context, arg1 string, arg2 float64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SPublish", arg0, arg1, arg2)
+	ret := m.ctrl.Call(m, "TSDecrBy", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// SPublish indicates an expected call of SPublish.
-func (mr *MockCmdableMockRecorder) SPublish(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TSDecrBy indicates an expected call of TSDecrBy.
+func (mr *MockCmdableMockRecorder) TSDecrBy(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SPublish", reflect.TypeOf((*MockCmdable)(nil).SPublish), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrBy", reflect.TypeOf((*MockCmdable)(nil).TSDecrBy), arg0, arg1, arg2)
 }
 
-// SRandMember mocks base method.
-func (m *MockCmdable) SRandMember(arg0 context.Context, arg1 string) *redis.StringCmd {
+// TSDecrByWithArgs mocks base method.
+func (m *MockCmdable) TSDecrByWithArgs(arg0 context.Context, arg1 string, arg2 float64, arg3 *redis.TSIncrDecrOptions) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SRandMember", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "TSDecrByWithArgs", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// SRandMember indicates an expected call of SRandMember.
-func (mr *MockCmdableMockRecorder) SRandMember(arg0, arg1 interface{}) *gomock.Call {
+// TSDecrByWithArgs indicates an expected call of TSDecrByWithArgs.
+func (mr *MockCmdableMockRecorder) TSDecrByWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMember", reflect.TypeOf((*MockCmdable)(nil).SRandMember), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDecrByWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSDecrByWithArgs), arg0, arg1, arg2, arg3)
 }
 
-// SRandMemberN mocks base method.
-func (m *MockCmdable) SRandMemberN(arg0 context.Context, arg1 string, arg2 int64) *redis.StringSliceCmd {
+// TSDel mocks base method.
+func (m *MockCmdable) TSDel(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SRandMemberN", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+	ret := m.ctrl.Call(m, "TSDel", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// SRandMemberN indicates an expected call of SRandMemberN.
-func (mr *MockCmdableMockRecorder) SRandMemberN(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TSDel indicates an expected call of TSDel.
+func (mr *MockCmdableMockRecorder) TSDel(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRandMemberN", reflect.TypeOf((*MockCmdable)(nil).SRandMemberN), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDel", reflect.TypeOf((*MockCmdable)(nil).TSDel), arg0, arg1, arg2, arg3)
 }
 
-// SRem mocks base method.
-func (m *MockCmdable) SRem(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+// TSDeleteRule mocks base method.
+func (m *MockCmdable) TSDeleteRule(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SRem", varargs...)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TSDeleteRule", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// SRem indicates an expected call of SRem.
-func (mr *MockCmdableMockRecorder) SRem(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TSDeleteRule indicates an expected call of TSDeleteRule.
+func (mr *MockCmdableMockRecorder) TSDeleteRule(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SRem", reflect.TypeOf((*MockCmdable)(nil).SRem), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSDeleteRule", reflect.TypeOf((*MockCmdable)(nil).TSDeleteRule), arg0, arg1, arg2)
 }
 
-// SScan mocks base method.
-func (m *MockCmdable) SScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd {
+// TSGet mocks base method.
+func (m *MockCmdable) TSGet(arg0 context.Context, arg1 string) *redis.TSTimestampValueCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SScan", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.ScanCmd)
+	ret := m.ctrl.Call(m, "TSGet", arg0, arg1)
+	ret0, _ := ret[0].(*redis.TSTimestampValueCmd)
 	return ret0
 }
 
-// SScan indicates an expected call of SScan.
-func (mr *MockCmdableMockRecorder) SScan(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// TSGet indicates an expected call of TSGet.
+func (mr *MockCmdableMockRecorder) TSGet(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SScan", reflect.TypeOf((*MockCmdable)(nil).SScan), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGet", reflect.TypeOf((*MockCmdable)(nil).TSGet), arg0, arg1)
 }
 
-// SUnion mocks base method.
-func (m *MockCmdable) SUnion(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd {
-	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SUnion", varargs...)
-	ret0, _ := ret[0].(*redis.StringSliceCmd)
+// TSGetWithArgs mocks base method.
+func (m *MockCmdable) 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
 }
 
-// SUnion indicates an expected call of SUnion.
-func (mr *MockCmdableMockRecorder) SUnion(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// TSGetWithArgs indicates an expected call of TSGetWithArgs.
+func (mr *MockCmdableMockRecorder) TSGetWithArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnion", reflect.TypeOf((*MockCmdable)(nil).SUnion), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSGetWithArgs), arg0, arg1, arg2)
 }
 
-// SUnionStore mocks base method.
-func (m *MockCmdable) SUnionStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
+// TSIncrBy mocks base method.
+func (m *MockCmdable) TSIncrBy(arg0 context.Context, arg1 string, arg2 float64) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
-	for _, a := range arg2 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "SUnionStore", varargs...)
+	ret := m.ctrl.Call(m, "TSIncrBy", arg0, arg1, arg2)
 	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// SUnionStore indicates an expected call of SUnionStore.
-func (mr *MockCmdableMockRecorder) SUnionStore(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+// TSIncrBy indicates an expected call of TSIncrBy.
+func (mr *MockCmdableMockRecorder) TSIncrBy(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SUnionStore", reflect.TypeOf((*MockCmdable)(nil).SUnionStore), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrBy", reflect.TypeOf((*MockCmdable)(nil).TSIncrBy), arg0, arg1, arg2)
 }
 
-// Save mocks base method.
-func (m *MockCmdable) Save(arg0 context.Context) *redis.StatusCmd {
+// TSIncrByWithArgs mocks base method.
+func (m *MockCmdable) TSIncrByWithArgs(arg0 context.Context, arg1 string, arg2 float64, arg3 *redis.TSIncrDecrOptions) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Save", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSIncrByWithArgs", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.IntCmd)
 	return ret0
 }
 
-// Save indicates an expected call of Save.
-func (mr *MockCmdableMockRecorder) Save(arg0 interface{}) *gomock.Call {
+// TSIncrByWithArgs indicates an expected call of TSIncrByWithArgs.
+func (mr *MockCmdableMockRecorder) TSIncrByWithArgs(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockCmdable)(nil).Save), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSIncrByWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSIncrByWithArgs), arg0, arg1, arg2, arg3)
 }
 
-// Scan mocks base method.
-func (m *MockCmdable) Scan(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64) *redis.ScanCmd {
+// TSInfo mocks base method.
+func (m *MockCmdable) TSInfo(arg0 context.Context, arg1 string) *redis.MapStringInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Scan", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.ScanCmd)
+	ret := m.ctrl.Call(m, "TSInfo", arg0, arg1)
+	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
 	return ret0
 }
 
-// Scan indicates an expected call of Scan.
-func (mr *MockCmdableMockRecorder) Scan(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSInfo indicates an expected call of TSInfo.
+func (mr *MockCmdableMockRecorder) TSInfo(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Scan", reflect.TypeOf((*MockCmdable)(nil).Scan), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfo", reflect.TypeOf((*MockCmdable)(nil).TSInfo), arg0, arg1)
 }
 
-// ScanType mocks base method.
-func (m *MockCmdable) ScanType(arg0 context.Context, arg1 uint64, arg2 string, arg3 int64, arg4 string) *redis.ScanCmd {
+// TSInfoWithArgs mocks base method.
+func (m *MockCmdable) TSInfoWithArgs(arg0 context.Context, arg1 string, arg2 *redis.TSInfoOptions) *redis.MapStringInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ScanType", arg0, arg1, arg2, arg3, arg4)
-	ret0, _ := ret[0].(*redis.ScanCmd)
+	ret := m.ctrl.Call(m, "TSInfoWithArgs", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.MapStringInterfaceCmd)
 	return ret0
 }
 
-// ScanType indicates an expected call of ScanType.
-func (mr *MockCmdableMockRecorder) ScanType(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+// TSInfoWithArgs indicates an expected call of TSInfoWithArgs.
+func (mr *MockCmdableMockRecorder) TSInfoWithArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScanType", reflect.TypeOf((*MockCmdable)(nil).ScanType), arg0, arg1, arg2, arg3, arg4)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSInfoWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSInfoWithArgs), arg0, arg1, arg2)
 }
 
-// ScriptExists mocks base method.
-func (m *MockCmdable) ScriptExists(arg0 context.Context, arg1 ...string) *redis.BoolSliceCmd {
+// TSMAdd mocks base method.
+func (m *MockCmdable) TSMAdd(arg0 context.Context, arg1 [][]any) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
-	for _, a := range arg1 {
-		varargs = append(varargs, a)
-	}
-	ret := m.ctrl.Call(m, "ScriptExists", varargs...)
-	ret0, _ := ret[0].(*redis.BoolSliceCmd)
+	ret := m.ctrl.Call(m, "TSMAdd", arg0, arg1)
+	ret0, _ := ret[0].(*redis.IntSliceCmd)
 	return ret0
 }
 
-// ScriptExists indicates an expected call of ScriptExists.
-func (mr *MockCmdableMockRecorder) ScriptExists(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+// TSMAdd indicates an expected call of TSMAdd.
+func (mr *MockCmdableMockRecorder) TSMAdd(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptExists", reflect.TypeOf((*MockCmdable)(nil).ScriptExists), varargs...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMAdd", reflect.TypeOf((*MockCmdable)(nil).TSMAdd), arg0, arg1)
 }
 
-// ScriptFlush mocks base method.
-func (m *MockCmdable) ScriptFlush(arg0 context.Context) *redis.StatusCmd {
+// TSMGet mocks base method.
+func (m *MockCmdable) TSMGet(arg0 context.Context, arg1 []string) *redis.MapStringSliceInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ScriptFlush", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSMGet", arg0, arg1)
+	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
 	return ret0
 }
 
-// ScriptFlush indicates an expected call of ScriptFlush.
-func (mr *MockCmdableMockRecorder) ScriptFlush(arg0 interface{}) *gomock.Call {
+// TSMGet indicates an expected call of TSMGet.
+func (mr *MockCmdableMockRecorder) TSMGet(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptFlush", reflect.TypeOf((*MockCmdable)(nil).ScriptFlush), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGet", reflect.TypeOf((*MockCmdable)(nil).TSMGet), arg0, arg1)
 }
 
-// ScriptKill mocks base method.
-func (m *MockCmdable) ScriptKill(arg0 context.Context) *redis.StatusCmd {
+// TSMGetWithArgs mocks base method.
+func (m *MockCmdable) TSMGetWithArgs(arg0 context.Context, arg1 []string, arg2 *redis.TSMGetOptions) *redis.MapStringSliceInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ScriptKill", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSMGetWithArgs", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
 	return ret0
 }
 
-// ScriptKill indicates an expected call of ScriptKill.
-func (mr *MockCmdableMockRecorder) ScriptKill(arg0 interface{}) *gomock.Call {
+// TSMGetWithArgs indicates an expected call of TSMGetWithArgs.
+func (mr *MockCmdableMockRecorder) TSMGetWithArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptKill", reflect.TypeOf((*MockCmdable)(nil).ScriptKill), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMGetWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMGetWithArgs), arg0, arg1, arg2)
 }
 
-// ScriptLoad mocks base method.
-func (m *MockCmdable) ScriptLoad(arg0 context.Context, arg1 string) *redis.StringCmd {
+// TSMRange mocks base method.
+func (m *MockCmdable) TSMRange(arg0 context.Context, arg1, arg2 int, arg3 []string) *redis.MapStringSliceInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ScriptLoad", arg0, arg1)
-	ret0, _ := ret[0].(*redis.StringCmd)
+	ret := m.ctrl.Call(m, "TSMRange", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
 	return ret0
 }
 
-// ScriptLoad indicates an expected call of ScriptLoad.
-func (mr *MockCmdableMockRecorder) ScriptLoad(arg0, arg1 interface{}) *gomock.Call {
+// TSMRange indicates an expected call of TSMRange.
+func (mr *MockCmdableMockRecorder) TSMRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ScriptLoad", reflect.TypeOf((*MockCmdable)(nil).ScriptLoad), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRange", reflect.TypeOf((*MockCmdable)(nil).TSMRange), arg0, arg1, arg2, arg3)
 }
 
-// Set mocks base method.
-func (m *MockCmdable) Set(arg0 context.Context, arg1 string, arg2 interface{}, arg3 time.Duration) *redis.StatusCmd {
+// TSMRangeWithArgs mocks base method.
+func (m *MockCmdable) TSMRangeWithArgs(arg0 context.Context, arg1, arg2 int, arg3 []string, arg4 *redis.TSMRangeOptions) *redis.MapStringSliceInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Set", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSMRangeWithArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
 	return ret0
 }
 
-// Set indicates an expected call of Set.
-func (mr *MockCmdableMockRecorder) Set(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSMRangeWithArgs indicates an expected call of TSMRangeWithArgs.
+func (mr *MockCmdableMockRecorder) TSMRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockCmdable)(nil).Set), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMRangeWithArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SetArgs mocks base method.
-func (m *MockCmdable) SetArgs(arg0 context.Context, arg1 string, arg2 interface{}, arg3 redis.SetArgs) *redis.StatusCmd {
+// TSMRevRange mocks base method.
+func (m *MockCmdable) TSMRevRange(arg0 context.Context, arg1, arg2 int, arg3 []string) *redis.MapStringSliceInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetArgs", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSMRevRange", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
 	return ret0
 }
 
-// SetArgs indicates an expected call of SetArgs.
-func (mr *MockCmdableMockRecorder) SetArgs(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSMRevRange indicates an expected call of TSMRevRange.
+func (mr *MockCmdableMockRecorder) TSMRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetArgs", reflect.TypeOf((*MockCmdable)(nil).SetArgs), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRange", reflect.TypeOf((*MockCmdable)(nil).TSMRevRange), arg0, arg1, arg2, arg3)
 }
 
-// SetBit mocks base method.
-func (m *MockCmdable) SetBit(arg0 context.Context, arg1 string, arg2 int64, arg3 int) *redis.IntCmd {
+// TSMRevRangeWithArgs mocks base method.
+func (m *MockCmdable) TSMRevRangeWithArgs(arg0 context.Context, arg1, arg2 int, arg3 []string, arg4 *redis.TSMRevRangeOptions) *redis.MapStringSliceInterfaceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetBit", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TSMRevRangeWithArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.MapStringSliceInterfaceCmd)
 	return ret0
 }
 
-// SetBit indicates an expected call of SetBit.
-func (mr *MockCmdableMockRecorder) SetBit(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSMRevRangeWithArgs indicates an expected call of TSMRevRangeWithArgs.
+func (mr *MockCmdableMockRecorder) TSMRevRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBit", reflect.TypeOf((*MockCmdable)(nil).SetBit), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSMRevRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSMRevRangeWithArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SetEx mocks base method.
-func (m *MockCmdable) SetEx(arg0 context.Context, arg1 string, arg2 interface{}, arg3 time.Duration) *redis.StatusCmd {
+// TSQueryIndex mocks base method.
+func (m *MockCmdable) TSQueryIndex(arg0 context.Context, arg1 []string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetEx", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSQueryIndex", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// SetEx indicates an expected call of SetEx.
-func (mr *MockCmdableMockRecorder) SetEx(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSQueryIndex indicates an expected call of TSQueryIndex.
+func (mr *MockCmdableMockRecorder) TSQueryIndex(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEx", reflect.TypeOf((*MockCmdable)(nil).SetEx), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSQueryIndex", reflect.TypeOf((*MockCmdable)(nil).TSQueryIndex), arg0, arg1)
 }
 
-// SetNX mocks base method.
-func (m *MockCmdable) SetNX(arg0 context.Context, arg1 string, arg2 interface{}, arg3 time.Duration) *redis.BoolCmd {
+// TSRange mocks base method.
+func (m *MockCmdable) TSRange(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.TSTimestampValueSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetNX", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "TSRange", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
 	return ret0
 }
 
-// SetNX indicates an expected call of SetNX.
-func (mr *MockCmdableMockRecorder) SetNX(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSRange indicates an expected call of TSRange.
+func (mr *MockCmdableMockRecorder) TSRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNX", reflect.TypeOf((*MockCmdable)(nil).SetNX), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRange", reflect.TypeOf((*MockCmdable)(nil).TSRange), arg0, arg1, arg2, arg3)
 }
 
-// SetRange mocks base method.
-func (m *MockCmdable) SetRange(arg0 context.Context, arg1 string, arg2 int64, arg3 string) *redis.IntCmd {
+// TSRangeWithArgs mocks base method.
+func (m *MockCmdable) TSRangeWithArgs(arg0 context.Context, arg1 string, arg2, arg3 int, arg4 *redis.TSRangeOptions) *redis.TSTimestampValueSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetRange", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TSRangeWithArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
 	return ret0
 }
 
-// SetRange indicates an expected call of SetRange.
-func (mr *MockCmdableMockRecorder) SetRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSRangeWithArgs indicates an expected call of TSRangeWithArgs.
+func (mr *MockCmdableMockRecorder) TSRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRange", reflect.TypeOf((*MockCmdable)(nil).SetRange), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSRangeWithArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// SetXX mocks base method.
-func (m *MockCmdable) SetXX(arg0 context.Context, arg1 string, arg2 interface{}, arg3 time.Duration) *redis.BoolCmd {
+// TSRevRange mocks base method.
+func (m *MockCmdable) TSRevRange(arg0 context.Context, arg1 string, arg2, arg3 int) *redis.TSTimestampValueSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SetXX", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.BoolCmd)
+	ret := m.ctrl.Call(m, "TSRevRange", arg0, arg1, arg2, arg3)
+	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
 	return ret0
 }
 
-// SetXX indicates an expected call of SetXX.
-func (mr *MockCmdableMockRecorder) SetXX(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TSRevRange indicates an expected call of TSRevRange.
+func (mr *MockCmdableMockRecorder) TSRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetXX", reflect.TypeOf((*MockCmdable)(nil).SetXX), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRange", reflect.TypeOf((*MockCmdable)(nil).TSRevRange), arg0, arg1, arg2, arg3)
 }
 
-// Shutdown mocks base method.
-func (m *MockCmdable) Shutdown(arg0 context.Context) *redis.StatusCmd {
+// TSRevRangeWithArgs mocks base method.
+func (m *MockCmdable) TSRevRangeWithArgs(arg0 context.Context, arg1 string, arg2, arg3 int, arg4 *redis.TSRevRangeOptions) *redis.TSTimestampValueSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Shutdown", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TSRevRangeWithArgs", arg0, arg1, arg2, arg3, arg4)
+	ret0, _ := ret[0].(*redis.TSTimestampValueSliceCmd)
 	return ret0
 }
 
-// Shutdown indicates an expected call of Shutdown.
-func (mr *MockCmdableMockRecorder) Shutdown(arg0 interface{}) *gomock.Call {
+// TSRevRangeWithArgs indicates an expected call of TSRevRangeWithArgs.
+func (mr *MockCmdableMockRecorder) TSRevRangeWithArgs(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Shutdown", reflect.TypeOf((*MockCmdable)(nil).Shutdown), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TSRevRangeWithArgs", reflect.TypeOf((*MockCmdable)(nil).TSRevRangeWithArgs), arg0, arg1, arg2, arg3, arg4)
 }
 
-// ShutdownNoSave mocks base method.
-func (m *MockCmdable) ShutdownNoSave(arg0 context.Context) *redis.StatusCmd {
+// TTL mocks base method.
+func (m *MockCmdable) TTL(arg0 context.Context, arg1 string) *redis.DurationCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ShutdownNoSave", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "TTL", arg0, arg1)
+	ret0, _ := ret[0].(*redis.DurationCmd)
 	return ret0
 }
 
-// ShutdownNoSave indicates an expected call of ShutdownNoSave.
-func (mr *MockCmdableMockRecorder) ShutdownNoSave(arg0 interface{}) *gomock.Call {
+// TTL indicates an expected call of TTL.
+func (mr *MockCmdableMockRecorder) TTL(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownNoSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownNoSave), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockCmdable)(nil).TTL), arg0, arg1)
 }
 
-// ShutdownSave mocks base method.
-func (m *MockCmdable) ShutdownSave(arg0 context.Context) *redis.StatusCmd {
+// Time mocks base method.
+func (m *MockCmdable) Time(arg0 context.Context) *redis.TimeCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "ShutdownSave", arg0)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	ret := m.ctrl.Call(m, "Time", arg0)
+	ret0, _ := ret[0].(*redis.TimeCmd)
 	return ret0
 }
 
-// ShutdownSave indicates an expected call of ShutdownSave.
-func (mr *MockCmdableMockRecorder) ShutdownSave(arg0 interface{}) *gomock.Call {
+// Time indicates an expected call of Time.
+func (mr *MockCmdableMockRecorder) Time(arg0 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutdownSave", reflect.TypeOf((*MockCmdable)(nil).ShutdownSave), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockCmdable)(nil).Time), arg0)
 }
 
-// SlaveOf mocks base method.
-func (m *MockCmdable) SlaveOf(arg0 context.Context, arg1, arg2 string) *redis.StatusCmd {
+// TopKAdd mocks base method.
+func (m *MockCmdable) TopKAdd(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SlaveOf", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.StatusCmd)
+	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
 }
 
-// SlaveOf indicates an expected call of SlaveOf.
-func (mr *MockCmdableMockRecorder) SlaveOf(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TopKAdd indicates an expected call of TopKAdd.
+func (mr *MockCmdableMockRecorder) TopKAdd(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlaveOf", reflect.TypeOf((*MockCmdable)(nil).SlaveOf), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKAdd", reflect.TypeOf((*MockCmdable)(nil).TopKAdd), varargs...)
 }
 
-// SlowLogGet mocks base method.
-func (m *MockCmdable) SlowLogGet(arg0 context.Context, arg1 int64) *redis.SlowLogCmd {
+// TopKCount mocks base method.
+func (m *MockCmdable) TopKCount(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SlowLogGet", arg0, arg1)
-	ret0, _ := ret[0].(*redis.SlowLogCmd)
+	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
 }
 
-// SlowLogGet indicates an expected call of SlowLogGet.
-func (mr *MockCmdableMockRecorder) SlowLogGet(arg0, arg1 interface{}) *gomock.Call {
+// TopKCount indicates an expected call of TopKCount.
+func (mr *MockCmdableMockRecorder) TopKCount(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlowLogGet", reflect.TypeOf((*MockCmdable)(nil).SlowLogGet), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKCount", reflect.TypeOf((*MockCmdable)(nil).TopKCount), varargs...)
 }
 
-// Sort mocks base method.
-func (m *MockCmdable) Sort(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.StringSliceCmd {
+// TopKIncrBy mocks base method.
+func (m *MockCmdable) TopKIncrBy(arg0 context.Context, arg1 string, arg2 ...any) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Sort", arg0, arg1, arg2)
+	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
 }
 
-// Sort indicates an expected call of Sort.
-func (mr *MockCmdableMockRecorder) Sort(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TopKIncrBy indicates an expected call of TopKIncrBy.
+func (mr *MockCmdableMockRecorder) TopKIncrBy(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sort", reflect.TypeOf((*MockCmdable)(nil).Sort), arg0, arg1, arg2)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKIncrBy", reflect.TypeOf((*MockCmdable)(nil).TopKIncrBy), varargs...)
 }
 
-// SortInterfaces mocks base method.
-func (m *MockCmdable) SortInterfaces(arg0 context.Context, arg1 string, arg2 *redis.Sort) *redis.SliceCmd {
+// TopKInfo mocks base method.
+func (m *MockCmdable) TopKInfo(arg0 context.Context, arg1 string) *redis.TopKInfoCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SortInterfaces", arg0, arg1, arg2)
-	ret0, _ := ret[0].(*redis.SliceCmd)
+	ret := m.ctrl.Call(m, "TopKInfo", arg0, arg1)
+	ret0, _ := ret[0].(*redis.TopKInfoCmd)
 	return ret0
 }
 
-// SortInterfaces indicates an expected call of SortInterfaces.
-func (mr *MockCmdableMockRecorder) SortInterfaces(arg0, arg1, arg2 interface{}) *gomock.Call {
+// TopKInfo indicates an expected call of TopKInfo.
+func (mr *MockCmdableMockRecorder) TopKInfo(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortInterfaces", reflect.TypeOf((*MockCmdable)(nil).SortInterfaces), arg0, arg1, arg2)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKInfo", reflect.TypeOf((*MockCmdable)(nil).TopKInfo), arg0, arg1)
 }
 
-// SortStore mocks base method.
-func (m *MockCmdable) SortStore(arg0 context.Context, arg1, arg2 string, arg3 *redis.Sort) *redis.IntCmd {
+// TopKList mocks base method.
+func (m *MockCmdable) TopKList(arg0 context.Context, arg1 string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "SortStore", arg0, arg1, arg2, arg3)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TopKList", arg0, arg1)
+	ret0, _ := ret[0].(*redis.StringSliceCmd)
 	return ret0
 }
 
-// SortStore indicates an expected call of SortStore.
-func (mr *MockCmdableMockRecorder) SortStore(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+// TopKList indicates an expected call of TopKList.
+func (mr *MockCmdableMockRecorder) TopKList(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SortStore", reflect.TypeOf((*MockCmdable)(nil).SortStore), arg0, arg1, arg2, arg3)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKList", reflect.TypeOf((*MockCmdable)(nil).TopKList), arg0, arg1)
 }
 
-// StrLen mocks base method.
-func (m *MockCmdable) StrLen(arg0 context.Context, arg1 string) *redis.IntCmd {
+// TopKListWithCount mocks base method.
+func (m *MockCmdable) TopKListWithCount(arg0 context.Context, arg1 string) *redis.MapStringIntCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "StrLen", arg0, arg1)
-	ret0, _ := ret[0].(*redis.IntCmd)
+	ret := m.ctrl.Call(m, "TopKListWithCount", arg0, arg1)
+	ret0, _ := ret[0].(*redis.MapStringIntCmd)
 	return ret0
 }
 
-// StrLen indicates an expected call of StrLen.
-func (mr *MockCmdableMockRecorder) StrLen(arg0, arg1 interface{}) *gomock.Call {
+// TopKListWithCount indicates an expected call of TopKListWithCount.
+func (mr *MockCmdableMockRecorder) TopKListWithCount(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrLen", reflect.TypeOf((*MockCmdable)(nil).StrLen), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKListWithCount", reflect.TypeOf((*MockCmdable)(nil).TopKListWithCount), arg0, arg1)
 }
 
-// TTL mocks base method.
-func (m *MockCmdable) TTL(arg0 context.Context, arg1 string) *redis.DurationCmd {
+// TopKQuery mocks base method.
+func (m *MockCmdable) TopKQuery(arg0 context.Context, arg1 string, arg2 ...any) *redis.BoolSliceCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "TTL", arg0, arg1)
-	ret0, _ := ret[0].(*redis.DurationCmd)
+	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
 }
 
-// TTL indicates an expected call of TTL.
-func (mr *MockCmdableMockRecorder) TTL(arg0, arg1 interface{}) *gomock.Call {
+// TopKQuery indicates an expected call of TopKQuery.
+func (mr *MockCmdableMockRecorder) TopKQuery(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TTL", reflect.TypeOf((*MockCmdable)(nil).TTL), arg0, arg1)
+	varargs := append([]any{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKQuery", reflect.TypeOf((*MockCmdable)(nil).TopKQuery), varargs...)
 }
 
-// Time mocks base method.
-func (m *MockCmdable) Time(arg0 context.Context) *redis.TimeCmd {
+// TopKReserve mocks base method.
+func (m *MockCmdable) TopKReserve(arg0 context.Context, arg1 string, arg2 int64) *redis.StatusCmd {
 	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "Time", arg0)
-	ret0, _ := ret[0].(*redis.TimeCmd)
+	ret := m.ctrl.Call(m, "TopKReserve", arg0, arg1, arg2)
+	ret0, _ := ret[0].(*redis.StatusCmd)
 	return ret0
 }
 
-// Time indicates an expected call of Time.
-func (mr *MockCmdableMockRecorder) Time(arg0 interface{}) *gomock.Call {
+// TopKReserve indicates an expected call of TopKReserve.
+func (mr *MockCmdableMockRecorder) TopKReserve(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Time", reflect.TypeOf((*MockCmdable)(nil).Time), arg0)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TopKReserve", reflect.TypeOf((*MockCmdable)(nil).TopKReserve), arg0, arg1, arg2)
+}
+
+// TopKReserveWithOptions mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).TopKReserveWithOptions), arg0, arg1, arg2, arg3, arg4, arg5)
 }
 
 // Touch mocks base method.
 func (m *MockCmdable) Touch(arg0 context.Context, arg1 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
@@ -3249,9 +5744,9 @@ func (m *MockCmdable) Touch(arg0 context.Context, arg1 ...string) *redis.IntCmd
 }
 
 // Touch indicates an expected call of Touch.
-func (mr *MockCmdableMockRecorder) Touch(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) Touch(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
+	varargs := append([]any{arg0}, arg1...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Touch", reflect.TypeOf((*MockCmdable)(nil).Touch), varargs...)
 }
 
@@ -3279,7 +5774,7 @@ func (m *MockCmdable) TxPipelined(arg0 context.Context, arg1 func(redis.Pipeline
 }
 
 // TxPipelined indicates an expected call of TxPipelined.
-func (mr *MockCmdableMockRecorder) TxPipelined(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) TxPipelined(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxPipelined", reflect.TypeOf((*MockCmdable)(nil).TxPipelined), arg0, arg1)
 }
@@ -3293,7 +5788,7 @@ func (m *MockCmdable) Type(arg0 context.Context, arg1 string) *redis.StatusCmd {
 }
 
 // Type indicates an expected call of Type.
-func (mr *MockCmdableMockRecorder) Type(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) Type(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Type", reflect.TypeOf((*MockCmdable)(nil).Type), arg0, arg1)
 }
@@ -3301,7 +5796,7 @@ func (mr *MockCmdableMockRecorder) Type(arg0, arg1 interface{}) *gomock.Call {
 // Unlink mocks base method.
 func (m *MockCmdable) Unlink(arg0 context.Context, arg1 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
@@ -3311,16 +5806,16 @@ func (m *MockCmdable) Unlink(arg0 context.Context, arg1 ...string) *redis.IntCmd
 }
 
 // Unlink indicates an expected call of Unlink.
-func (mr *MockCmdableMockRecorder) Unlink(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) Unlink(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
+	varargs := append([]any{arg0}, arg1...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlink", reflect.TypeOf((*MockCmdable)(nil).Unlink), varargs...)
 }
 
 // XAck mocks base method.
 func (m *MockCmdable) XAck(arg0 context.Context, arg1, arg2 string, arg3 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1, arg2}
+	varargs := []any{arg0, arg1, arg2}
 	for _, a := range arg3 {
 		varargs = append(varargs, a)
 	}
@@ -3330,9 +5825,9 @@ func (m *MockCmdable) XAck(arg0 context.Context, arg1, arg2 string, arg3 ...stri
 }
 
 // XAck indicates an expected call of XAck.
-func (mr *MockCmdableMockRecorder) XAck(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XAck(arg0, arg1, arg2 any, arg3 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	varargs := append([]any{arg0, arg1, arg2}, arg3...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAck", reflect.TypeOf((*MockCmdable)(nil).XAck), varargs...)
 }
 
@@ -3345,7 +5840,7 @@ func (m *MockCmdable) XAdd(arg0 context.Context, arg1 *redis.XAddArgs) *redis.St
 }
 
 // XAdd indicates an expected call of XAdd.
-func (mr *MockCmdableMockRecorder) XAdd(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XAdd(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAdd", reflect.TypeOf((*MockCmdable)(nil).XAdd), arg0, arg1)
 }
@@ -3359,7 +5854,7 @@ func (m *MockCmdable) XAutoClaim(arg0 context.Context, arg1 *redis.XAutoClaimArg
 }
 
 // XAutoClaim indicates an expected call of XAutoClaim.
-func (mr *MockCmdableMockRecorder) XAutoClaim(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XAutoClaim(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaim", reflect.TypeOf((*MockCmdable)(nil).XAutoClaim), arg0, arg1)
 }
@@ -3373,7 +5868,7 @@ func (m *MockCmdable) XAutoClaimJustID(arg0 context.Context, arg1 *redis.XAutoCl
 }
 
 // XAutoClaimJustID indicates an expected call of XAutoClaimJustID.
-func (mr *MockCmdableMockRecorder) XAutoClaimJustID(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XAutoClaimJustID(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XAutoClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XAutoClaimJustID), arg0, arg1)
 }
@@ -3387,7 +5882,7 @@ func (m *MockCmdable) XClaim(arg0 context.Context, arg1 *redis.XClaimArgs) *redi
 }
 
 // XClaim indicates an expected call of XClaim.
-func (mr *MockCmdableMockRecorder) XClaim(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XClaim(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaim", reflect.TypeOf((*MockCmdable)(nil).XClaim), arg0, arg1)
 }
@@ -3401,7 +5896,7 @@ func (m *MockCmdable) XClaimJustID(arg0 context.Context, arg1 *redis.XClaimArgs)
 }
 
 // XClaimJustID indicates an expected call of XClaimJustID.
-func (mr *MockCmdableMockRecorder) XClaimJustID(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XClaimJustID(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XClaimJustID", reflect.TypeOf((*MockCmdable)(nil).XClaimJustID), arg0, arg1)
 }
@@ -3409,7 +5904,7 @@ func (mr *MockCmdableMockRecorder) XClaimJustID(arg0, arg1 interface{}) *gomock.
 // XDel mocks base method.
 func (m *MockCmdable) XDel(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -3419,9 +5914,9 @@ func (m *MockCmdable) XDel(arg0 context.Context, arg1 string, arg2 ...string) *r
 }
 
 // XDel indicates an expected call of XDel.
-func (mr *MockCmdableMockRecorder) XDel(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XDel(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XDel", reflect.TypeOf((*MockCmdable)(nil).XDel), varargs...)
 }
 
@@ -3434,7 +5929,7 @@ func (m *MockCmdable) XGroupCreate(arg0 context.Context, arg1, arg2, arg3 string
 }
 
 // XGroupCreate indicates an expected call of XGroupCreate.
-func (mr *MockCmdableMockRecorder) XGroupCreate(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XGroupCreate(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreate", reflect.TypeOf((*MockCmdable)(nil).XGroupCreate), arg0, arg1, arg2, arg3)
 }
@@ -3448,7 +5943,7 @@ func (m *MockCmdable) XGroupCreateConsumer(arg0 context.Context, arg1, arg2, arg
 }
 
 // XGroupCreateConsumer indicates an expected call of XGroupCreateConsumer.
-func (mr *MockCmdableMockRecorder) XGroupCreateConsumer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XGroupCreateConsumer(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateConsumer), arg0, arg1, arg2, arg3)
 }
@@ -3462,7 +5957,7 @@ func (m *MockCmdable) XGroupCreateMkStream(arg0 context.Context, arg1, arg2, arg
 }
 
 // XGroupCreateMkStream indicates an expected call of XGroupCreateMkStream.
-func (mr *MockCmdableMockRecorder) XGroupCreateMkStream(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XGroupCreateMkStream(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupCreateMkStream", reflect.TypeOf((*MockCmdable)(nil).XGroupCreateMkStream), arg0, arg1, arg2, arg3)
 }
@@ -3476,7 +5971,7 @@ func (m *MockCmdable) XGroupDelConsumer(arg0 context.Context, arg1, arg2, arg3 s
 }
 
 // XGroupDelConsumer indicates an expected call of XGroupDelConsumer.
-func (mr *MockCmdableMockRecorder) XGroupDelConsumer(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XGroupDelConsumer(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDelConsumer", reflect.TypeOf((*MockCmdable)(nil).XGroupDelConsumer), arg0, arg1, arg2, arg3)
 }
@@ -3490,7 +5985,7 @@ func (m *MockCmdable) XGroupDestroy(arg0 context.Context, arg1, arg2 string) *re
 }
 
 // XGroupDestroy indicates an expected call of XGroupDestroy.
-func (mr *MockCmdableMockRecorder) XGroupDestroy(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XGroupDestroy(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupDestroy", reflect.TypeOf((*MockCmdable)(nil).XGroupDestroy), arg0, arg1, arg2)
 }
@@ -3504,7 +5999,7 @@ func (m *MockCmdable) XGroupSetID(arg0 context.Context, arg1, arg2, arg3 string)
 }
 
 // XGroupSetID indicates an expected call of XGroupSetID.
-func (mr *MockCmdableMockRecorder) XGroupSetID(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XGroupSetID(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XGroupSetID", reflect.TypeOf((*MockCmdable)(nil).XGroupSetID), arg0, arg1, arg2, arg3)
 }
@@ -3518,7 +6013,7 @@ func (m *MockCmdable) XInfoConsumers(arg0 context.Context, arg1, arg2 string) *r
 }
 
 // XInfoConsumers indicates an expected call of XInfoConsumers.
-func (mr *MockCmdableMockRecorder) XInfoConsumers(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XInfoConsumers(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoConsumers", reflect.TypeOf((*MockCmdable)(nil).XInfoConsumers), arg0, arg1, arg2)
 }
@@ -3532,7 +6027,7 @@ func (m *MockCmdable) XInfoGroups(arg0 context.Context, arg1 string) *redis.XInf
 }
 
 // XInfoGroups indicates an expected call of XInfoGroups.
-func (mr *MockCmdableMockRecorder) XInfoGroups(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XInfoGroups(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoGroups", reflect.TypeOf((*MockCmdable)(nil).XInfoGroups), arg0, arg1)
 }
@@ -3546,7 +6041,7 @@ func (m *MockCmdable) XInfoStream(arg0 context.Context, arg1 string) *redis.XInf
 }
 
 // XInfoStream indicates an expected call of XInfoStream.
-func (mr *MockCmdableMockRecorder) XInfoStream(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XInfoStream(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStream", reflect.TypeOf((*MockCmdable)(nil).XInfoStream), arg0, arg1)
 }
@@ -3560,7 +6055,7 @@ func (m *MockCmdable) XInfoStreamFull(arg0 context.Context, arg1 string, arg2 in
 }
 
 // XInfoStreamFull indicates an expected call of XInfoStreamFull.
-func (mr *MockCmdableMockRecorder) XInfoStreamFull(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XInfoStreamFull(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XInfoStreamFull", reflect.TypeOf((*MockCmdable)(nil).XInfoStreamFull), arg0, arg1, arg2)
 }
@@ -3574,7 +6069,7 @@ func (m *MockCmdable) XLen(arg0 context.Context, arg1 string) *redis.IntCmd {
 }
 
 // XLen indicates an expected call of XLen.
-func (mr *MockCmdableMockRecorder) XLen(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XLen(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XLen", reflect.TypeOf((*MockCmdable)(nil).XLen), arg0, arg1)
 }
@@ -3588,7 +6083,7 @@ func (m *MockCmdable) XPending(arg0 context.Context, arg1, arg2 string) *redis.X
 }
 
 // XPending indicates an expected call of XPending.
-func (mr *MockCmdableMockRecorder) XPending(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XPending(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPending", reflect.TypeOf((*MockCmdable)(nil).XPending), arg0, arg1, arg2)
 }
@@ -3602,7 +6097,7 @@ func (m *MockCmdable) XPendingExt(arg0 context.Context, arg1 *redis.XPendingExtA
 }
 
 // XPendingExt indicates an expected call of XPendingExt.
-func (mr *MockCmdableMockRecorder) XPendingExt(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XPendingExt(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XPendingExt", reflect.TypeOf((*MockCmdable)(nil).XPendingExt), arg0, arg1)
 }
@@ -3616,7 +6111,7 @@ func (m *MockCmdable) XRange(arg0 context.Context, arg1, arg2, arg3 string) *red
 }
 
 // XRange indicates an expected call of XRange.
-func (mr *MockCmdableMockRecorder) XRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRange", reflect.TypeOf((*MockCmdable)(nil).XRange), arg0, arg1, arg2, arg3)
 }
@@ -3630,7 +6125,7 @@ func (m *MockCmdable) XRangeN(arg0 context.Context, arg1, arg2, arg3 string, arg
 }
 
 // XRangeN indicates an expected call of XRangeN.
-func (mr *MockCmdableMockRecorder) XRangeN(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XRangeN(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRangeN", reflect.TypeOf((*MockCmdable)(nil).XRangeN), arg0, arg1, arg2, arg3, arg4)
 }
@@ -3644,7 +6139,7 @@ func (m *MockCmdable) XRead(arg0 context.Context, arg1 *redis.XReadArgs) *redis.
 }
 
 // XRead indicates an expected call of XRead.
-func (mr *MockCmdableMockRecorder) XRead(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XRead(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRead", reflect.TypeOf((*MockCmdable)(nil).XRead), arg0, arg1)
 }
@@ -3658,7 +6153,7 @@ func (m *MockCmdable) XReadGroup(arg0 context.Context, arg1 *redis.XReadGroupArg
 }
 
 // XReadGroup indicates an expected call of XReadGroup.
-func (mr *MockCmdableMockRecorder) XReadGroup(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XReadGroup(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadGroup", reflect.TypeOf((*MockCmdable)(nil).XReadGroup), arg0, arg1)
 }
@@ -3666,7 +6161,7 @@ func (mr *MockCmdableMockRecorder) XReadGroup(arg0, arg1 interface{}) *gomock.Ca
 // XReadStreams mocks base method.
 func (m *MockCmdable) XReadStreams(arg0 context.Context, arg1 ...string) *redis.XStreamSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
@@ -3676,9 +6171,9 @@ func (m *MockCmdable) XReadStreams(arg0 context.Context, arg1 ...string) *redis.
 }
 
 // XReadStreams indicates an expected call of XReadStreams.
-func (mr *MockCmdableMockRecorder) XReadStreams(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XReadStreams(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
+	varargs := append([]any{arg0}, arg1...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XReadStreams", reflect.TypeOf((*MockCmdable)(nil).XReadStreams), varargs...)
 }
 
@@ -3691,7 +6186,7 @@ func (m *MockCmdable) XRevRange(arg0 context.Context, arg1, arg2, arg3 string) *
 }
 
 // XRevRange indicates an expected call of XRevRange.
-func (mr *MockCmdableMockRecorder) XRevRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRange", reflect.TypeOf((*MockCmdable)(nil).XRevRange), arg0, arg1, arg2, arg3)
 }
@@ -3705,7 +6200,7 @@ func (m *MockCmdable) XRevRangeN(arg0 context.Context, arg1, arg2, arg3 string,
 }
 
 // XRevRangeN indicates an expected call of XRevRangeN.
-func (mr *MockCmdableMockRecorder) XRevRangeN(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XRevRangeN(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XRevRangeN", reflect.TypeOf((*MockCmdable)(nil).XRevRangeN), arg0, arg1, arg2, arg3, arg4)
 }
@@ -3719,7 +6214,7 @@ func (m *MockCmdable) XTrimMaxLen(arg0 context.Context, arg1 string, arg2 int64)
 }
 
 // XTrimMaxLen indicates an expected call of XTrimMaxLen.
-func (mr *MockCmdableMockRecorder) XTrimMaxLen(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XTrimMaxLen(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLen", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLen), arg0, arg1, arg2)
 }
@@ -3733,7 +6228,7 @@ func (m *MockCmdable) XTrimMaxLenApprox(arg0 context.Context, arg1 string, arg2,
 }
 
 // XTrimMaxLenApprox indicates an expected call of XTrimMaxLenApprox.
-func (mr *MockCmdableMockRecorder) XTrimMaxLenApprox(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XTrimMaxLenApprox(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMaxLenApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMaxLenApprox), arg0, arg1, arg2, arg3)
 }
@@ -3747,7 +6242,7 @@ func (m *MockCmdable) XTrimMinID(arg0 context.Context, arg1, arg2 string) *redis
 }
 
 // XTrimMinID indicates an expected call of XTrimMinID.
-func (mr *MockCmdableMockRecorder) XTrimMinID(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XTrimMinID(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinID", reflect.TypeOf((*MockCmdable)(nil).XTrimMinID), arg0, arg1, arg2)
 }
@@ -3761,7 +6256,7 @@ func (m *MockCmdable) XTrimMinIDApprox(arg0 context.Context, arg1, arg2 string,
 }
 
 // XTrimMinIDApprox indicates an expected call of XTrimMinIDApprox.
-func (mr *MockCmdableMockRecorder) XTrimMinIDApprox(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) XTrimMinIDApprox(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "XTrimMinIDApprox", reflect.TypeOf((*MockCmdable)(nil).XTrimMinIDApprox), arg0, arg1, arg2, arg3)
 }
@@ -3769,7 +6264,7 @@ func (mr *MockCmdableMockRecorder) XTrimMinIDApprox(arg0, arg1, arg2, arg3 inter
 // ZAdd mocks base method.
 func (m *MockCmdable) ZAdd(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -3779,9 +6274,9 @@ func (m *MockCmdable) ZAdd(arg0 context.Context, arg1 string, arg2 ...redis.Z) *
 }
 
 // ZAdd indicates an expected call of ZAdd.
-func (mr *MockCmdableMockRecorder) ZAdd(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZAdd(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAdd", reflect.TypeOf((*MockCmdable)(nil).ZAdd), varargs...)
 }
 
@@ -3794,7 +6289,7 @@ func (m *MockCmdable) ZAddArgs(arg0 context.Context, arg1 string, arg2 redis.ZAd
 }
 
 // ZAddArgs indicates an expected call of ZAddArgs.
-func (mr *MockCmdableMockRecorder) ZAddArgs(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZAddArgs(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgs", reflect.TypeOf((*MockCmdable)(nil).ZAddArgs), arg0, arg1, arg2)
 }
@@ -3808,15 +6303,53 @@ func (m *MockCmdable) ZAddArgsIncr(arg0 context.Context, arg1 string, arg2 redis
 }
 
 // ZAddArgsIncr indicates an expected call of ZAddArgsIncr.
-func (mr *MockCmdableMockRecorder) ZAddArgsIncr(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZAddArgsIncr(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddArgsIncr", reflect.TypeOf((*MockCmdable)(nil).ZAddArgsIncr), arg0, arg1, arg2)
 }
 
+// ZAddGT mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).ZAddGT), varargs...)
+}
+
+// ZAddLT mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).ZAddLT), varargs...)
+}
+
 // ZAddNX mocks base method.
 func (m *MockCmdable) ZAddNX(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -3826,16 +6359,16 @@ func (m *MockCmdable) ZAddNX(arg0 context.Context, arg1 string, arg2 ...redis.Z)
 }
 
 // ZAddNX indicates an expected call of ZAddNX.
-func (mr *MockCmdableMockRecorder) ZAddNX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZAddNX(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddNX", reflect.TypeOf((*MockCmdable)(nil).ZAddNX), varargs...)
 }
 
 // ZAddXX mocks base method.
 func (m *MockCmdable) ZAddXX(arg0 context.Context, arg1 string, arg2 ...redis.Z) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -3845,9 +6378,9 @@ func (m *MockCmdable) ZAddXX(arg0 context.Context, arg1 string, arg2 ...redis.Z)
 }
 
 // ZAddXX indicates an expected call of ZAddXX.
-func (mr *MockCmdableMockRecorder) ZAddXX(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZAddXX(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZAddXX", reflect.TypeOf((*MockCmdable)(nil).ZAddXX), varargs...)
 }
 
@@ -3860,7 +6393,7 @@ func (m *MockCmdable) ZCard(arg0 context.Context, arg1 string) *redis.IntCmd {
 }
 
 // ZCard indicates an expected call of ZCard.
-func (mr *MockCmdableMockRecorder) ZCard(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZCard(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCard", reflect.TypeOf((*MockCmdable)(nil).ZCard), arg0, arg1)
 }
@@ -3874,7 +6407,7 @@ func (m *MockCmdable) ZCount(arg0 context.Context, arg1, arg2, arg3 string) *red
 }
 
 // ZCount indicates an expected call of ZCount.
-func (mr *MockCmdableMockRecorder) ZCount(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZCount(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZCount", reflect.TypeOf((*MockCmdable)(nil).ZCount), arg0, arg1, arg2, arg3)
 }
@@ -3882,7 +6415,7 @@ func (mr *MockCmdableMockRecorder) ZCount(arg0, arg1, arg2, arg3 interface{}) *g
 // ZDiff mocks base method.
 func (m *MockCmdable) ZDiff(arg0 context.Context, arg1 ...string) *redis.StringSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
@@ -3892,16 +6425,16 @@ func (m *MockCmdable) ZDiff(arg0 context.Context, arg1 ...string) *redis.StringS
 }
 
 // ZDiff indicates an expected call of ZDiff.
-func (mr *MockCmdableMockRecorder) ZDiff(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZDiff(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
+	varargs := append([]any{arg0}, arg1...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiff", reflect.TypeOf((*MockCmdable)(nil).ZDiff), varargs...)
 }
 
 // ZDiffStore mocks base method.
 func (m *MockCmdable) ZDiffStore(arg0 context.Context, arg1 string, arg2 ...string) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -3911,16 +6444,16 @@ func (m *MockCmdable) ZDiffStore(arg0 context.Context, arg1 string, arg2 ...stri
 }
 
 // ZDiffStore indicates an expected call of ZDiffStore.
-func (mr *MockCmdableMockRecorder) ZDiffStore(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZDiffStore(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffStore", reflect.TypeOf((*MockCmdable)(nil).ZDiffStore), varargs...)
 }
 
 // ZDiffWithScores mocks base method.
 func (m *MockCmdable) ZDiffWithScores(arg0 context.Context, arg1 ...string) *redis.ZSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0}
+	varargs := []any{arg0}
 	for _, a := range arg1 {
 		varargs = append(varargs, a)
 	}
@@ -3930,9 +6463,9 @@ func (m *MockCmdable) ZDiffWithScores(arg0 context.Context, arg1 ...string) *red
 }
 
 // ZDiffWithScores indicates an expected call of ZDiffWithScores.
-func (mr *MockCmdableMockRecorder) ZDiffWithScores(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZDiffWithScores(arg0 any, arg1 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0}, arg1...)
+	varargs := append([]any{arg0}, arg1...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZDiffWithScores", reflect.TypeOf((*MockCmdable)(nil).ZDiffWithScores), varargs...)
 }
 
@@ -3945,7 +6478,7 @@ func (m *MockCmdable) ZIncrBy(arg0 context.Context, arg1 string, arg2 float64, a
 }
 
 // ZIncrBy indicates an expected call of ZIncrBy.
-func (mr *MockCmdableMockRecorder) ZIncrBy(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZIncrBy(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZIncrBy", reflect.TypeOf((*MockCmdable)(nil).ZIncrBy), arg0, arg1, arg2, arg3)
 }
@@ -3959,11 +6492,30 @@ func (m *MockCmdable) ZInter(arg0 context.Context, arg1 *redis.ZStore) *redis.St
 }
 
 // ZInter indicates an expected call of ZInter.
-func (mr *MockCmdableMockRecorder) ZInter(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZInter(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInter", reflect.TypeOf((*MockCmdable)(nil).ZInter), arg0, arg1)
 }
 
+// ZInterCard mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).ZInterCard), varargs...)
+}
+
 // ZInterStore mocks base method.
 func (m *MockCmdable) ZInterStore(arg0 context.Context, arg1 string, arg2 *redis.ZStore) *redis.IntCmd {
 	m.ctrl.T.Helper()
@@ -3973,7 +6525,7 @@ func (m *MockCmdable) ZInterStore(arg0 context.Context, arg1 string, arg2 *redis
 }
 
 // ZInterStore indicates an expected call of ZInterStore.
-func (mr *MockCmdableMockRecorder) ZInterStore(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZInterStore(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterStore", reflect.TypeOf((*MockCmdable)(nil).ZInterStore), arg0, arg1, arg2)
 }
@@ -3987,7 +6539,7 @@ func (m *MockCmdable) ZInterWithScores(arg0 context.Context, arg1 *redis.ZStore)
 }
 
 // ZInterWithScores indicates an expected call of ZInterWithScores.
-func (mr *MockCmdableMockRecorder) ZInterWithScores(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZInterWithScores(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZInterWithScores", reflect.TypeOf((*MockCmdable)(nil).ZInterWithScores), arg0, arg1)
 }
@@ -4001,15 +6553,34 @@ func (m *MockCmdable) ZLexCount(arg0 context.Context, arg1, arg2, arg3 string) *
 }
 
 // ZLexCount indicates an expected call of ZLexCount.
-func (mr *MockCmdableMockRecorder) ZLexCount(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZLexCount(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZLexCount", reflect.TypeOf((*MockCmdable)(nil).ZLexCount), arg0, arg1, arg2, arg3)
 }
 
+// ZMPop mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) 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((*MockCmdable)(nil).ZMPop), varargs...)
+}
+
 // ZMScore mocks base method.
 func (m *MockCmdable) ZMScore(arg0 context.Context, arg1 string, arg2 ...string) *redis.FloatSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -4019,16 +6590,16 @@ func (m *MockCmdable) ZMScore(arg0 context.Context, arg1 string, arg2 ...string)
 }
 
 // ZMScore indicates an expected call of ZMScore.
-func (mr *MockCmdableMockRecorder) ZMScore(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZMScore(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZMScore", reflect.TypeOf((*MockCmdable)(nil).ZMScore), varargs...)
 }
 
 // ZPopMax mocks base method.
 func (m *MockCmdable) ZPopMax(arg0 context.Context, arg1 string, arg2 ...int64) *redis.ZSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -4038,16 +6609,16 @@ func (m *MockCmdable) ZPopMax(arg0 context.Context, arg1 string, arg2 ...int64)
 }
 
 // ZPopMax indicates an expected call of ZPopMax.
-func (mr *MockCmdableMockRecorder) ZPopMax(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZPopMax(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMax", reflect.TypeOf((*MockCmdable)(nil).ZPopMax), varargs...)
 }
 
 // ZPopMin mocks base method.
 func (m *MockCmdable) ZPopMin(arg0 context.Context, arg1 string, arg2 ...int64) *redis.ZSliceCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -4057,9 +6628,9 @@ func (m *MockCmdable) ZPopMin(arg0 context.Context, arg1 string, arg2 ...int64)
 }
 
 // ZPopMin indicates an expected call of ZPopMin.
-func (mr *MockCmdableMockRecorder) ZPopMin(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZPopMin(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZPopMin", reflect.TypeOf((*MockCmdable)(nil).ZPopMin), varargs...)
 }
 
@@ -4072,7 +6643,7 @@ func (m *MockCmdable) ZRandMember(arg0 context.Context, arg1 string, arg2 int) *
 }
 
 // ZRandMember indicates an expected call of ZRandMember.
-func (mr *MockCmdableMockRecorder) ZRandMember(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRandMember(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMember", reflect.TypeOf((*MockCmdable)(nil).ZRandMember), arg0, arg1, arg2)
 }
@@ -4086,7 +6657,7 @@ func (m *MockCmdable) ZRandMemberWithScores(arg0 context.Context, arg1 string, a
 }
 
 // ZRandMemberWithScores indicates an expected call of ZRandMemberWithScores.
-func (mr *MockCmdableMockRecorder) ZRandMemberWithScores(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRandMemberWithScores(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRandMemberWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRandMemberWithScores), arg0, arg1, arg2)
 }
@@ -4100,7 +6671,7 @@ func (m *MockCmdable) ZRange(arg0 context.Context, arg1 string, arg2, arg3 int64
 }
 
 // ZRange indicates an expected call of ZRange.
-func (mr *MockCmdableMockRecorder) ZRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRange", reflect.TypeOf((*MockCmdable)(nil).ZRange), arg0, arg1, arg2, arg3)
 }
@@ -4114,7 +6685,7 @@ func (m *MockCmdable) ZRangeArgs(arg0 context.Context, arg1 redis.ZRangeArgs) *r
 }
 
 // ZRangeArgs indicates an expected call of ZRangeArgs.
-func (mr *MockCmdableMockRecorder) ZRangeArgs(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeArgs(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgs", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgs), arg0, arg1)
 }
@@ -4128,7 +6699,7 @@ func (m *MockCmdable) ZRangeArgsWithScores(arg0 context.Context, arg1 redis.ZRan
 }
 
 // ZRangeArgsWithScores indicates an expected call of ZRangeArgsWithScores.
-func (mr *MockCmdableMockRecorder) ZRangeArgsWithScores(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeArgsWithScores(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeArgsWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeArgsWithScores), arg0, arg1)
 }
@@ -4142,7 +6713,7 @@ func (m *MockCmdable) ZRangeByLex(arg0 context.Context, arg1 string, arg2 *redis
 }
 
 // ZRangeByLex indicates an expected call of ZRangeByLex.
-func (mr *MockCmdableMockRecorder) ZRangeByLex(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeByLex(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRangeByLex), arg0, arg1, arg2)
 }
@@ -4156,7 +6727,7 @@ func (m *MockCmdable) ZRangeByScore(arg0 context.Context, arg1 string, arg2 *red
 }
 
 // ZRangeByScore indicates an expected call of ZRangeByScore.
-func (mr *MockCmdableMockRecorder) ZRangeByScore(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeByScore(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScore), arg0, arg1, arg2)
 }
@@ -4170,7 +6741,7 @@ func (m *MockCmdable) ZRangeByScoreWithScores(arg0 context.Context, arg1 string,
 }
 
 // ZRangeByScoreWithScores indicates an expected call of ZRangeByScoreWithScores.
-func (mr *MockCmdableMockRecorder) ZRangeByScoreWithScores(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeByScoreWithScores(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeByScoreWithScores), arg0, arg1, arg2)
 }
@@ -4184,7 +6755,7 @@ func (m *MockCmdable) ZRangeStore(arg0 context.Context, arg1 string, arg2 redis.
 }
 
 // ZRangeStore indicates an expected call of ZRangeStore.
-func (mr *MockCmdableMockRecorder) ZRangeStore(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeStore(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeStore", reflect.TypeOf((*MockCmdable)(nil).ZRangeStore), arg0, arg1, arg2)
 }
@@ -4198,7 +6769,7 @@ func (m *MockCmdable) ZRangeWithScores(arg0 context.Context, arg1 string, arg2,
 }
 
 // ZRangeWithScores indicates an expected call of ZRangeWithScores.
-func (mr *MockCmdableMockRecorder) ZRangeWithScores(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRangeWithScores(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRangeWithScores), arg0, arg1, arg2, arg3)
 }
@@ -4212,15 +6783,29 @@ func (m *MockCmdable) ZRank(arg0 context.Context, arg1, arg2 string) *redis.IntC
 }
 
 // ZRank indicates an expected call of ZRank.
-func (mr *MockCmdableMockRecorder) ZRank(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRank(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRank", reflect.TypeOf((*MockCmdable)(nil).ZRank), arg0, arg1, arg2)
 }
 
+// ZRankWithScore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ZRankWithScore(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRankWithScore), arg0, arg1, arg2)
+}
+
 // ZRem mocks base method.
-func (m *MockCmdable) ZRem(arg0 context.Context, arg1 string, arg2 ...interface{}) *redis.IntCmd {
+func (m *MockCmdable) ZRem(arg0 context.Context, arg1 string, arg2 ...any) *redis.IntCmd {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{arg0, arg1}
+	varargs := []any{arg0, arg1}
 	for _, a := range arg2 {
 		varargs = append(varargs, a)
 	}
@@ -4230,9 +6815,9 @@ func (m *MockCmdable) ZRem(arg0 context.Context, arg1 string, arg2 ...interface{
 }
 
 // ZRem indicates an expected call of ZRem.
-func (mr *MockCmdableMockRecorder) ZRem(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRem(arg0, arg1 any, arg2 ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	varargs := append([]any{arg0, arg1}, arg2...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRem", reflect.TypeOf((*MockCmdable)(nil).ZRem), varargs...)
 }
 
@@ -4245,7 +6830,7 @@ func (m *MockCmdable) ZRemRangeByLex(arg0 context.Context, arg1, arg2, arg3 stri
 }
 
 // ZRemRangeByLex indicates an expected call of ZRemRangeByLex.
-func (mr *MockCmdableMockRecorder) ZRemRangeByLex(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRemRangeByLex(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByLex), arg0, arg1, arg2, arg3)
 }
@@ -4259,7 +6844,7 @@ func (m *MockCmdable) ZRemRangeByRank(arg0 context.Context, arg1 string, arg2, a
 }
 
 // ZRemRangeByRank indicates an expected call of ZRemRangeByRank.
-func (mr *MockCmdableMockRecorder) ZRemRangeByRank(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRemRangeByRank(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByRank", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByRank), arg0, arg1, arg2, arg3)
 }
@@ -4273,7 +6858,7 @@ func (m *MockCmdable) ZRemRangeByScore(arg0 context.Context, arg1, arg2, arg3 st
 }
 
 // ZRemRangeByScore indicates an expected call of ZRemRangeByScore.
-func (mr *MockCmdableMockRecorder) ZRemRangeByScore(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRemRangeByScore(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRemRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRemRangeByScore), arg0, arg1, arg2, arg3)
 }
@@ -4287,7 +6872,7 @@ func (m *MockCmdable) ZRevRange(arg0 context.Context, arg1 string, arg2, arg3 in
 }
 
 // ZRevRange indicates an expected call of ZRevRange.
-func (mr *MockCmdableMockRecorder) ZRevRange(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRevRange(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRange", reflect.TypeOf((*MockCmdable)(nil).ZRevRange), arg0, arg1, arg2, arg3)
 }
@@ -4301,7 +6886,7 @@ func (m *MockCmdable) ZRevRangeByLex(arg0 context.Context, arg1 string, arg2 *re
 }
 
 // ZRevRangeByLex indicates an expected call of ZRevRangeByLex.
-func (mr *MockCmdableMockRecorder) ZRevRangeByLex(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRevRangeByLex(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByLex", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByLex), arg0, arg1, arg2)
 }
@@ -4315,7 +6900,7 @@ func (m *MockCmdable) ZRevRangeByScore(arg0 context.Context, arg1 string, arg2 *
 }
 
 // ZRevRangeByScore indicates an expected call of ZRevRangeByScore.
-func (mr *MockCmdableMockRecorder) ZRevRangeByScore(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRevRangeByScore(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScore), arg0, arg1, arg2)
 }
@@ -4329,7 +6914,7 @@ func (m *MockCmdable) ZRevRangeByScoreWithScores(arg0 context.Context, arg1 stri
 }
 
 // ZRevRangeByScoreWithScores indicates an expected call of ZRevRangeByScoreWithScores.
-func (mr *MockCmdableMockRecorder) ZRevRangeByScoreWithScores(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRevRangeByScoreWithScores(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeByScoreWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeByScoreWithScores), arg0, arg1, arg2)
 }
@@ -4343,7 +6928,7 @@ func (m *MockCmdable) ZRevRangeWithScores(arg0 context.Context, arg1 string, arg
 }
 
 // ZRevRangeWithScores indicates an expected call of ZRevRangeWithScores.
-func (mr *MockCmdableMockRecorder) ZRevRangeWithScores(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRevRangeWithScores(arg0, arg1, arg2, arg3 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRangeWithScores", reflect.TypeOf((*MockCmdable)(nil).ZRevRangeWithScores), arg0, arg1, arg2, arg3)
 }
@@ -4357,11 +6942,25 @@ func (m *MockCmdable) ZRevRank(arg0 context.Context, arg1, arg2 string) *redis.I
 }
 
 // ZRevRank indicates an expected call of ZRevRank.
-func (mr *MockCmdableMockRecorder) ZRevRank(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZRevRank(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRank", reflect.TypeOf((*MockCmdable)(nil).ZRevRank), arg0, arg1, arg2)
 }
 
+// ZRevRankWithScore mocks base method.
+func (m *MockCmdable) 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 *MockCmdableMockRecorder) ZRevRankWithScore(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZRevRankWithScore", reflect.TypeOf((*MockCmdable)(nil).ZRevRankWithScore), arg0, arg1, arg2)
+}
+
 // ZScan mocks base method.
 func (m *MockCmdable) ZScan(arg0 context.Context, arg1 string, arg2 uint64, arg3 string, arg4 int64) *redis.ScanCmd {
 	m.ctrl.T.Helper()
@@ -4371,7 +6970,7 @@ func (m *MockCmdable) ZScan(arg0 context.Context, arg1 string, arg2 uint64, arg3
 }
 
 // ZScan indicates an expected call of ZScan.
-func (mr *MockCmdableMockRecorder) ZScan(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZScan(arg0, arg1, arg2, arg3, arg4 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScan", reflect.TypeOf((*MockCmdable)(nil).ZScan), arg0, arg1, arg2, arg3, arg4)
 }
@@ -4385,7 +6984,7 @@ func (m *MockCmdable) ZScore(arg0 context.Context, arg1, arg2 string) *redis.Flo
 }
 
 // ZScore indicates an expected call of ZScore.
-func (mr *MockCmdableMockRecorder) ZScore(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZScore(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZScore", reflect.TypeOf((*MockCmdable)(nil).ZScore), arg0, arg1, arg2)
 }
@@ -4399,7 +6998,7 @@ func (m *MockCmdable) ZUnion(arg0 context.Context, arg1 redis.ZStore) *redis.Str
 }
 
 // ZUnion indicates an expected call of ZUnion.
-func (mr *MockCmdableMockRecorder) ZUnion(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZUnion(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnion", reflect.TypeOf((*MockCmdable)(nil).ZUnion), arg0, arg1)
 }
@@ -4413,7 +7012,7 @@ func (m *MockCmdable) ZUnionStore(arg0 context.Context, arg1 string, arg2 *redis
 }
 
 // ZUnionStore indicates an expected call of ZUnionStore.
-func (mr *MockCmdableMockRecorder) ZUnionStore(arg0, arg1, arg2 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZUnionStore(arg0, arg1, arg2 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionStore", reflect.TypeOf((*MockCmdable)(nil).ZUnionStore), arg0, arg1, arg2)
 }
@@ -4427,7 +7026,7 @@ func (m *MockCmdable) ZUnionWithScores(arg0 context.Context, arg1 redis.ZStore)
 }
 
 // ZUnionWithScores indicates an expected call of ZUnionWithScores.
-func (mr *MockCmdableMockRecorder) ZUnionWithScores(arg0, arg1 interface{}) *gomock.Call {
+func (mr *MockCmdableMockRecorder) ZUnionWithScores(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ZUnionWithScores", reflect.TypeOf((*MockCmdable)(nil).ZUnionWithScores), arg0, arg1)
 }