diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 000000000..1af2323fe
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+doctests/* @dmaier-redislabs
diff --git a/.github/spellcheck-settings.yml b/.github/spellcheck-settings.yml
new file mode 100644
index 000000000..b8ca6cca6
--- /dev/null
+++ b/.github/spellcheck-settings.yml
@@ -0,0 +1,29 @@
+matrix:
+- name: Markdown
+  expect_match: false
+  apsell:
+    lang: en
+    d: en_US
+    ignore-case: true
+  dictionary:
+    wordlists:
+    - .github/wordlist.txt
+    output: wordlist.dic
+  pipeline:
+  - pyspelling.filters.markdown:
+      markdown_extensions:
+      - markdown.extensions.extra:
+  - pyspelling.filters.html:
+      comments: false
+      attributes:
+      - alt
+      ignores:
+      - ':matches(code, pre)'
+      - code
+      - pre
+      - blockquote
+      - img
+  sources:
+  - 'README.md'
+  - 'FAQ.md'
+  - 'docs/**'
diff --git a/.github/wordlist.txt b/.github/wordlist.txt
new file mode 100644
index 000000000..52fdc1bcf
--- /dev/null
+++ b/.github/wordlist.txt
@@ -0,0 +1,60 @@
+ACLs
+autoload
+autoloader
+autoloading
+analytics
+Autoloading
+backend
+backends
+behaviour
+CAS
+ClickHouse
+config
+customizable
+Customizable
+dataset
+de
+DisableIdentity
+ElastiCache
+extensibility
+FPM
+Golang
+IANA
+keyspace
+keyspaces
+Kvrocks
+localhost
+Lua
+MSSQL
+namespace
+NoSQL
+ORM
+Packagist
+PhpRedis
+pipelining
+pluggable
+Predis
+PSR
+Quickstart
+README
+rebalanced
+rebalancing
+redis
+Redis
+RocksDB
+runtime
+SHA
+sharding
+SETNAME
+SSL
+struct
+stunnel
+TCP
+TLS
+uri
+URI
+url
+variadic
+RedisStack
+RedisGears
+RedisTimeseries
\ No newline at end of file
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 30fb9e851..4061bbdff 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -16,11 +16,11 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go-version: [1.19.x, 1.20.x]
+        go-version: [1.19.x, 1.20.x, 1.21.x]
 
     services:
       redis:
-        image: redis:7.2-rc
+        image: redis/redis-stack-server:edge
         options: >-
           --health-cmd "redis-cli ping" --health-interval 10s --health-timeout 5s --health-retries 5
         ports:
@@ -28,12 +28,12 @@ jobs:
 
     steps:
       - name: Set up ${{ matrix.go-version }}
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go-version }}
 
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Test
         run: make test
diff --git a/.github/workflows/doctests.yaml b/.github/workflows/doctests.yaml
index 00b0063bf..6e49e6477 100644
--- a/.github/workflows/doctests.yaml
+++ b/.github/workflows/doctests.yaml
@@ -25,17 +25,17 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        go-version: [ "1.18", "1.19", "1.20" ]
+        go-version: [ "1.18", "1.19", "1.20", "1.21" ]
 
     steps:
       - name: Set up ${{ matrix.go-version }}
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v5
         with:
           go-version: ${{ matrix.go-version }}
 
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Test doc examples
         working-directory: ./doctests
-        run: go test
\ No newline at end of file
+        run: go test
diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml
index d3232ecbd..a139f5dab 100644
--- a/.github/workflows/golangci-lint.yml
+++ b/.github/workflows/golangci-lint.yml
@@ -21,6 +21,6 @@ jobs:
     name: lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: golangci-lint
-        uses: golangci/golangci-lint-action@v3
+        uses: golangci/golangci-lint-action@v4
diff --git a/.github/workflows/release-drafter.yml b/.github/workflows/release-drafter.yml
index eebb3e678..6695abfe4 100644
--- a/.github/workflows/release-drafter.yml
+++ b/.github/workflows/release-drafter.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       # Drafts your next Release notes as Pull Requests are merged into "master"
-      - uses: release-drafter/release-drafter@v5
+      - uses: release-drafter/release-drafter@v6
         with:
           # (Optional) specify config name to use, relative to .github/. Default: release-drafter.yml
            config-name: release-drafter-config.yml
diff --git a/.github/workflows/spellcheck.yml b/.github/workflows/spellcheck.yml
new file mode 100644
index 000000000..f739a5424
--- /dev/null
+++ b/.github/workflows/spellcheck.yml
@@ -0,0 +1,14 @@
+name: spellcheck
+on:
+  pull_request:
+jobs:
+  check-spelling:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Check Spelling
+        uses: rojopolis/spellcheck-github-actions@0.36.0
+        with:
+          config_path: .github/spellcheck-settings.yml
+          task_name: Markdown
diff --git a/.github/workflows/stale-issues.yml b/.github/workflows/stale-issues.yml
new file mode 100644
index 000000000..445af1c81
--- /dev/null
+++ b/.github/workflows/stale-issues.yml
@@ -0,0 +1,25 @@
+name: "Close stale issues"
+on:
+  schedule:
+  - cron: "0 0 * * *"
+
+permissions: {}
+jobs:
+  stale:
+    permissions:
+      issues: write  #  to close stale issues (actions/stale)
+      pull-requests: write  #  to close stale PRs (actions/stale)
+
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/stale@v9
+      with:
+        repo-token: ${{ secrets.GITHUB_TOKEN }}
+        stale-issue-message: 'This issue is marked stale. It will be closed in 30 days if it is not updated.'
+        stale-pr-message: 'This pull request is marked stale. It will be closed in 30 days if it is not updated.'
+        days-before-stale: 365
+        days-before-close: 30
+        stale-issue-label: "Stale"
+        stale-pr-label: "Stale"
+        operations-per-run: 10
+        remove-stale-when-updated: true
diff --git a/.github/workflows/test-redis-enterprise.yml b/.github/workflows/test-redis-enterprise.yml
new file mode 100644
index 000000000..940f0eae7
--- /dev/null
+++ b/.github/workflows/test-redis-enterprise.yml
@@ -0,0 +1,57 @@
+name: RE Tests
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: build
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        go-version: [1.21.x]
+        re-build: ["7.4.2-54"]
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Clone Redis EE docker repository
+        uses: actions/checkout@v4
+        with:
+          repository: RedisLabs/redis-ee-docker
+          path: redis-ee
+
+      - name: Set up ${{ matrix.go-version }}
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go-version }}
+
+      - name: Build cluster
+        working-directory: redis-ee
+        env:
+          IMAGE: "redislabs/redis:${{ matrix.re-build }}"
+          RE_USERNAME: test@test.com
+          RE_PASS: 12345
+          RE_CLUSTER_NAME: re-test
+          RE_USE_OSS_CLUSTER: false
+          RE_DB_PORT: 6379
+        run: ./build.sh
+
+      - name: Test
+        env:
+          RE_CLUSTER: "1"
+        run: |
+          go test \
+          --ginkgo.skip-file="ring_test.go" \
+          --ginkgo.skip-file="sentinel_test.go" \
+          --ginkgo.skip-file="osscluster_test.go" \
+          --ginkgo.skip-file="pubsub_test.go" \
+          --ginkgo.skip-file="gears_commands_test.go" \
+          --ginkgo.label-filter='!NonRedisEnterprise'
diff --git a/.gitignore b/.gitignore
index 64a7cb512..6f868895b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@
 testdata/*
 .idea/
 .DS_Store
+*.tar.gz
+*.dic
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 297438a9f..e1652b179 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+## Unreleased
+
+### Changed
+
+* `go-redis` won't skip span creation if the parent spans is not recording. ([#2980](https://github.com/redis/go-redis/issues/2980))
+  Users can use the OpenTelemetry sampler to control the sampling behavior.
+  For instance, you can use the `ParentBased(NeverSample())` sampler from `go.opentelemetry.io/otel/sdk/trace` to keep
+  a similar behavior (drop orphan spans) of `go-redis` as before.
+
 ## [9.0.5](https://github.com/redis/go-redis/compare/v9.0.4...v9.0.5) (2023-05-29)
 
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000..90030b89f
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,101 @@
+# Contributing
+
+## Introduction
+
+We appreciate your interest in considering contributing to go-redis.
+Community contributions mean a lot to us.
+
+## Contributions we need
+
+You may already know how you'd like to contribute, whether it's a fix for a bug you
+encountered, or a new feature your team wants to use.
+
+If you don't know where to start, consider improving
+documentation, bug triaging, and writing tutorials are all examples of
+helpful contributions that mean less work for you.
+
+## Your First Contribution
+
+Unsure where to begin contributing? You can start by looking through
+[help-wanted
+issues](https://github.com/redis/go-redis/issues?q=is%3Aopen+is%3Aissue+label%3ahelp-wanted).
+
+Never contributed to open source before? Here are a couple of friendly
+tutorials:
+
+-   <http://makeapullrequest.com/>
+-   <http://www.firsttimersonly.com/>
+
+## Getting Started
+
+Here's how to get started with your code contribution:
+
+1.  Create your own fork of go-redis
+2.  Do the changes in your fork
+3.  If you need a development environment, run `make test`. Note: this clones and builds the latest release of [redis](https://redis.io). You also need a redis-stack-server docker, in order to run the capabilities tests. This can be started by running:
+    ```docker run -p 6379:6379 -it redis/redis-stack-server:edge```
+4.  While developing, make sure the tests pass by running `make tests`
+5.  If you like the change and think the project could use it, send a
+    pull request
+
+To see what else is part of the automation, run `invoke -l`
+
+## Testing
+
+Call `make test` to run all tests, including linters.
+
+Continuous Integration uses these same wrappers to run all of these
+tests against multiple versions of python. Feel free to test your
+changes against all the go versions supported, as declared by the
+[build.yml](./.github/workflows/build.yml) file.
+
+### Troubleshooting
+
+If you get any errors when running `make test`, make sure
+that you are using supported versions of Docker and go.
+
+## How to Report a Bug
+
+### Security Vulnerabilities
+
+**NOTE**: If you find a security vulnerability, do NOT open an issue.
+Email [Redis Open Source (<oss@redis.com>)](mailto:oss@redis.com) instead.
+
+In order to determine whether you are dealing with a security issue, ask
+yourself these two questions:
+
+-   Can I access something that's not mine, or something I shouldn't
+    have access to?
+-   Can I disable something for other people?
+
+If the answer to either of those two questions are *yes*, then you're
+probably dealing with a security issue. Note that even if you answer
+*no*  to both questions, you may still be dealing with a security
+issue, so if you're unsure, just email [us](mailto:oss@redis.com).
+
+### Everything Else
+
+When filing an issue, make sure to answer these five questions:
+
+1.  What version of go-redis are you using?
+2.  What version of redis are you using?
+3.  What did you do?
+4.  What did you expect to see?
+5.  What did you see instead?
+
+## Suggest a feature or enhancement
+
+If you'd like to contribute a new feature, make sure you check our
+issue list to see if someone has already proposed it. Work may already
+be underway on the feature you want or we may have rejected a
+feature like it already.
+
+If you don't see anything, open a new issue that describes the feature
+you would like and how it should work.
+
+## Code review process
+
+The core team regularly looks at pull requests. We will provide
+feedback as soon as possible. After receiving our feedback, please respond
+within two weeks. After that time, we may close your PR if it isn't
+showing any activity.
diff --git a/Makefile b/Makefile
index 285f65dd5..ea5321f29 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,12 @@
 GO_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {} \; | sort)
 
 test: testdeps
+	$(eval GO_VERSION := $(shell go version | cut -d " " -f 3 | cut -d. -f2))
 	set -e; for dir in $(GO_MOD_DIRS); do \
+	  if echo "$${dir}" | grep -q "./example" && [ "$(GO_VERSION)" = "19" ]; then \
+	    echo "Skipping go test in $${dir} due to Go version 1.19 and dir contains ./example"; \
+	    continue; \
+	  fi; \
 	  echo "go test in $${dir}"; \
 	  (cd "$${dir}" && \
 	    go mod tidy -compat=1.18 && \
@@ -19,17 +24,20 @@ testdeps: testdata/redis/src/redis-server
 bench: testdeps
 	go test ./... -test.run=NONE -test.bench=. -test.benchmem
 
-.PHONY: all test testdeps bench
+.PHONY: all test testdeps bench fmt
+
+build:
+	go build .
 
 testdata/redis:
 	mkdir -p $@
-	wget -qO- https://download.redis.io/releases/redis-7.2-rc1.tar.gz | tar xvz --strip-components=1 -C $@
+	wget -qO- https://download.redis.io/releases/redis-7.2.1.tar.gz | tar xvz --strip-components=1 -C $@
 
 testdata/redis/src/redis-server: testdata/redis
 	cd $< && make all
 
 fmt:
-	gofmt -w -s ./
+	gofumpt -w ./
 	goimports -w  -local github.com/redis/go-redis ./
 
 go_mod_tidy:
diff --git a/README.md b/README.md
index 36d60fd4e..e7df5dfd6 100644
--- a/README.md
+++ b/README.md
@@ -10,8 +10,22 @@
 > use it to monitor applications and set up automatic alerts to receive notifications via email,
 > Slack, Telegram, and others.
 >
-> See [OpenTelemetry](example/otel) example which demonstrates how you can use Uptrace to monitor
-> go-redis.
+> See [OpenTelemetry](https://github.com/redis/go-redis/tree/master/example/otel) example which
+> demonstrates how you can use Uptrace to monitor go-redis.
+
+## How do I Redis?
+
+[Learn for free at Redis University](https://university.redis.com/)
+
+[Build faster with the Redis Launchpad](https://launchpad.redis.com/)
+
+[Try the Redis Cloud](https://redis.com/try-free/)
+
+[Dive in developer tutorials](https://developer.redis.com/)
+
+[Join the Redis community](https://redis.com/community/)
+
+[Work at Redis](https://redis.com/company/careers/jobs/)
 
 ## Documentation
 
@@ -37,8 +51,8 @@ key value NoSQL database that uses RocksDB as storage engine and is compatible w
 
 ## Features
 
-- Redis 3 commands except QUIT, MONITOR, and SYNC.
-- Automatic connection pooling with
+- Redis commands except QUIT and SYNC.
+- Automatic connection pooling.
 - [Pub/Sub](https://redis.uptrace.dev/guide/go-redis-pubsub.html).
 - [Pipelines and transactions](https://redis.uptrace.dev/guide/go-redis-pipelines.html).
 - [Scripting](https://redis.uptrace.dev/guide/lua-scripting.html).
@@ -46,6 +60,7 @@ key value NoSQL database that uses RocksDB as storage engine and is compatible w
 - [Redis Cluster](https://redis.uptrace.dev/guide/go-redis-cluster.html).
 - [Redis Ring](https://redis.uptrace.dev/guide/ring.html).
 - [Redis Performance Monitoring](https://redis.uptrace.dev/guide/redis-performance-monitoring.html).
+- [Redis Probabilistic [RedisStack]](https://redis.io/docs/data-types/probabilistic/)
 
 ## Installation
 
@@ -68,8 +83,9 @@ go get github.com/redis/go-redis/v9
 ```go
 import (
     "context"
-    "github.com/redis/go-redis/v9"
     "fmt"
+
+    "github.com/redis/go-redis/v9"
 )
 
 var ctx = context.Background()
@@ -105,6 +121,71 @@ func ExampleClient() {
 }
 ```
 
+The above can be modified to specify the version of the RESP protocol by adding the `protocol`
+option to the `Options` struct:
+
+```go
+    rdb := redis.NewClient(&redis.Options{
+        Addr:     "localhost:6379",
+        Password: "", // no password set
+        DB:       0,  // use default DB
+        Protocol: 3, // specify 2 for RESP 2 or 3 for RESP 3
+    })
+
+```
+
+### Connecting via a redis url
+
+go-redis also supports connecting via the
+[redis uri specification](https://github.com/redis/redis-specifications/tree/master/uri/redis.txt).
+The example below demonstrates how the connection can easily be configured using a string, adhering
+to this specification.
+
+```go
+import (
+    "github.com/redis/go-redis/v9"
+)
+
+func ExampleClient() *redis.Client {
+    url := "redis://user:password@localhost:6379/0?protocol=3"
+    opts, err := redis.ParseURL(url)
+    if err != nil {
+        panic(err)
+    }
+
+    return redis.NewClient(opts)
+}
+
+```
+
+
+### Advanced Configuration
+
+go-redis supports extending the client identification phase to allow projects to send their own custom client identification.
+
+#### Default Client Identification
+
+By default, go-redis automatically sends the client library name and version during the connection process. This feature is available in redis-server as of version 7.2. As a result, the command is "fire and forget", meaning it should fail silently, in the case that the redis server does not support this feature.
+
+#### Disabling Identity Verification
+
+When connection identity verification is not required or needs to be explicitly disabled, a `DisableIndentity` configuration option exists. In V10 of this library, `DisableIndentity` will become `DisableIdentity` in order to fix the associated typo.
+
+To disable verification, set the `DisableIndentity` option to `true` in the Redis client options:
+
+```go
+rdb := redis.NewClient(&redis.Options{
+    Addr:            "localhost:6379",
+    Password:        "",
+    DB:              0,
+    DisableIndentity: true, // Disable set-info on connect
+})
+```
+
+## Contributing
+
+Please see [out contributing guidelines](CONTRIBUTING.md) to help us improve this library!
+
 ## Look and feel
 
 Some corner cases:
@@ -167,7 +248,8 @@ Lastly, run:
 go test
 ```
 
-Another option is to run your specific tests with an already running redis. The example below, tests against a redis running on port 9999.:
+Another option is to run your specific tests with an already running redis. The example below, tests
+against a redis running on port 9999.:
 
 ```shell
 REDIS_PORT=9999 go test <your options>
diff --git a/acl_commands.go b/acl_commands.go
new file mode 100644
index 000000000..06847be2e
--- /dev/null
+++ b/acl_commands.go
@@ -0,0 +1,35 @@
+package redis
+
+import "context"
+
+type ACLCmdable interface {
+	ACLDryRun(ctx context.Context, username string, command ...interface{}) *StringCmd
+	ACLLog(ctx context.Context, count int64) *ACLLogCmd
+	ACLLogReset(ctx context.Context) *StatusCmd
+}
+
+func (c cmdable) ACLDryRun(ctx context.Context, username string, command ...interface{}) *StringCmd {
+	args := make([]interface{}, 0, 3+len(command))
+	args = append(args, "acl", "dryrun", username)
+	args = append(args, command...)
+	cmd := NewStringCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ACLLog(ctx context.Context, count int64) *ACLLogCmd {
+	args := make([]interface{}, 0, 3)
+	args = append(args, "acl", "log")
+	if count > 0 {
+		args = append(args, count)
+	}
+	cmd := NewACLLogCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ACLLogReset(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "acl", "log", "reset")
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/bench_decode_test.go b/bench_decode_test.go
index de53064f2..16bdf2cd3 100644
--- a/bench_decode_test.go
+++ b/bench_decode_test.go
@@ -30,6 +30,7 @@ func NewClientStub(resp []byte) *ClientStub {
 		Dialer: func(ctx context.Context, network, addr string) (net.Conn, error) {
 			return stub.stubConn(initHello), nil
 		},
+		DisableIndentity: true,
 	})
 	return stub
 }
@@ -45,6 +46,8 @@ func NewClusterClientStub(resp []byte) *ClientStub {
 		Dialer: func(ctx context.Context, network, addr string) (net.Conn, error) {
 			return stub.stubConn(initHello), nil
 		},
+		DisableIndentity: true,
+
 		ClusterSlots: func(_ context.Context) ([]ClusterSlot, error) {
 			return []ClusterSlot{
 				{
@@ -56,14 +59,6 @@ func NewClusterClientStub(resp []byte) *ClientStub {
 		},
 	})
 
-	// init command.
-	tmpClient := NewClient(&Options{Addr: ":6379"})
-	cmdsInfo, err := tmpClient.Command(ctx).Result()
-	_ = tmpClient.Close()
-	client.cmdsInfoCache = newCmdsInfoCache(func(_ context.Context) (map[string]*CommandInfo, error) {
-		return cmdsInfo, err
-	})
-
 	stub.Cmdable = client
 	return stub
 }
diff --git a/bitmap_commands.go b/bitmap_commands.go
new file mode 100644
index 000000000..a21558289
--- /dev/null
+++ b/bitmap_commands.go
@@ -0,0 +1,161 @@
+package redis
+
+import (
+	"context"
+	"errors"
+)
+
+type BitMapCmdable interface {
+	GetBit(ctx context.Context, key string, offset int64) *IntCmd
+	SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd
+	BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd
+	BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd
+	BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd
+	BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd
+	BitOpNot(ctx context.Context, destKey string, key string) *IntCmd
+	BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd
+	BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *IntCmd
+	BitField(ctx context.Context, key string, values ...interface{}) *IntSliceCmd
+	BitFieldRO(ctx context.Context, key string, values ...interface{}) *IntSliceCmd
+}
+
+func (c cmdable) GetBit(ctx context.Context, key string, offset int64) *IntCmd {
+	cmd := NewIntCmd(ctx, "getbit", key, offset)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd {
+	cmd := NewIntCmd(
+		ctx,
+		"setbit",
+		key,
+		offset,
+		value,
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type BitCount struct {
+	Start, End int64
+	Unit       string // BYTE(default) | BIT
+}
+
+const BitCountIndexByte string = "BYTE"
+const BitCountIndexBit string = "BIT"
+
+func (c cmdable) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd {
+	args := make([]any, 2, 5)
+	args[0] = "bitcount"
+	args[1] = key
+	if bitCount != nil {
+		args = append(args, bitCount.Start, bitCount.End)
+		if bitCount.Unit != "" {
+			if bitCount.Unit != BitCountIndexByte && bitCount.Unit != BitCountIndexBit {
+				cmd := NewIntCmd(ctx)
+				cmd.SetErr(errors.New("redis: invalid bitcount index"))
+				return cmd
+			}
+			args = append(args, bitCount.Unit)
+		}
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) bitOp(ctx context.Context, op, destKey string, keys ...string) *IntCmd {
+	args := make([]interface{}, 3+len(keys))
+	args[0] = "bitop"
+	args[1] = op
+	args[2] = destKey
+	for i, key := range keys {
+		args[3+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd {
+	return c.bitOp(ctx, "and", destKey, keys...)
+}
+
+func (c cmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd {
+	return c.bitOp(ctx, "or", destKey, keys...)
+}
+
+func (c cmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd {
+	return c.bitOp(ctx, "xor", destKey, keys...)
+}
+
+func (c cmdable) BitOpNot(ctx context.Context, destKey string, key string) *IntCmd {
+	return c.bitOp(ctx, "not", destKey, key)
+}
+
+// BitPos is an API before Redis version 7.0, cmd: bitpos key bit start end
+// if you need the `byte | bit` parameter, please use `BitPosSpan`.
+func (c cmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd {
+	args := make([]interface{}, 3+len(pos))
+	args[0] = "bitpos"
+	args[1] = key
+	args[2] = bit
+	switch len(pos) {
+	case 0:
+	case 1:
+		args[3] = pos[0]
+	case 2:
+		args[3] = pos[0]
+		args[4] = pos[1]
+	default:
+		panic("too many arguments")
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BitPosSpan supports the `byte | bit` parameters in redis version 7.0,
+// the bitpos command defaults to using byte type for the `start-end` range,
+// which means it counts in bytes from start to end. you can set the value
+// of "span" to determine the type of `start-end`.
+// span = "bit", cmd: bitpos key bit start end bit
+// span = "byte", cmd: bitpos key bit start end byte
+func (c cmdable) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *IntCmd {
+	cmd := NewIntCmd(ctx, "bitpos", key, bit, start, end, span)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BitField accepts multiple values:
+//   - BitField("set", "i1", "offset1", "value1","cmd2", "type2", "offset2", "value2")
+//   - BitField([]string{"cmd1", "type1", "offset1", "value1","cmd2", "type2", "offset2", "value2"})
+//   - BitField([]interface{}{"cmd1", "type1", "offset1", "value1","cmd2", "type2", "offset2", "value2"})
+func (c cmdable) BitField(ctx context.Context, key string, values ...interface{}) *IntSliceCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "bitfield"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BitFieldRO - Read-only variant of the BITFIELD command.
+// It is like the original BITFIELD but only accepts GET subcommand and can safely be used in read-only replicas.
+// - BitFieldRO(ctx, key, "<Encoding0>", "<Offset0>", "<Encoding1>","<Offset1>")
+func (c cmdable) BitFieldRO(ctx context.Context, key string, values ...interface{}) *IntSliceCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "BITFIELD_RO"
+	args[1] = key
+	if len(values)%2 != 0 {
+		panic("BitFieldRO: invalid number of arguments, must be even")
+	}
+	for i := 0; i < len(values); i += 2 {
+		args = append(args, "GET", values[i], values[i+1])
+	}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/bitmap_commands_test.go b/bitmap_commands_test.go
new file mode 100644
index 000000000..f3cc3205f
--- /dev/null
+++ b/bitmap_commands_test.go
@@ -0,0 +1,98 @@
+package redis_test
+
+import (
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+	"github.com/redis/go-redis/v9"
+)
+
+type bitCountExpected struct {
+	Start    int64
+	End      int64
+	Expected int64
+}
+
+var _ = Describe("BitCountBite", func() {
+	var client *redis.Client
+	key := "bit_count_test"
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+		values := []int{0, 1, 0, 0, 1, 0, 1, 0, 1, 1}
+		for i, v := range values {
+			cmd := client.SetBit(ctx, key, int64(i), v)
+			Expect(cmd.Err()).NotTo(HaveOccurred())
+		}
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("bit count bite", func() {
+		var expected = []bitCountExpected{
+			{0, 0, 0},
+			{0, 1, 1},
+			{0, 2, 1},
+			{0, 3, 1},
+			{0, 4, 2},
+			{0, 5, 2},
+			{0, 6, 3},
+			{0, 7, 3},
+			{0, 8, 4},
+			{0, 9, 5},
+		}
+
+		for _, e := range expected {
+			cmd := client.BitCount(ctx, key, &redis.BitCount{Start: e.Start, End: e.End, Unit: redis.BitCountIndexBit})
+			Expect(cmd.Err()).NotTo(HaveOccurred())
+			Expect(cmd.Val()).To(Equal(e.Expected))
+		}
+	})
+})
+
+var _ = Describe("BitCountByte", func() {
+	var client *redis.Client
+	key := "bit_count_test"
+
+	BeforeEach(func() {
+		client = redis.NewClient(redisOptions())
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+		values := []int{0, 0, 0, 0, 0, 0, 0, 1, 1, 1}
+		for i, v := range values {
+			cmd := client.SetBit(ctx, key, int64(i), v)
+			Expect(cmd.Err()).NotTo(HaveOccurred())
+		}
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("bit count byte", func() {
+		var expected = []bitCountExpected{
+			{0, 0, 1},
+			{0, 1, 3},
+		}
+
+		for _, e := range expected {
+			cmd := client.BitCount(ctx, key, &redis.BitCount{Start: e.Start, End: e.End, Unit: redis.BitCountIndexByte})
+			Expect(cmd.Err()).NotTo(HaveOccurred())
+			Expect(cmd.Val()).To(Equal(e.Expected))
+		}
+	})
+
+	It("bit count byte with no unit specified", func() {
+		var expected = []bitCountExpected{
+			{0, 0, 1},
+			{0, 1, 3},
+		}
+
+		for _, e := range expected {
+			cmd := client.BitCount(ctx, key, &redis.BitCount{Start: e.Start, End: e.End})
+			Expect(cmd.Err()).NotTo(HaveOccurred())
+			Expect(cmd.Val()).To(Equal(e.Expected))
+		}
+	})
+})
diff --git a/cluster_commands.go b/cluster_commands.go
index b13f8e7e9..0caf0977a 100644
--- a/cluster_commands.go
+++ b/cluster_commands.go
@@ -1,109 +1,192 @@
 package redis
 
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-)
-
-func (c *ClusterClient) DBSize(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "dbsize")
-	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		var size int64
-		err := c.ForEachMaster(ctx, func(ctx context.Context, master *Client) error {
-			n, err := master.DBSize(ctx).Result()
-			if err != nil {
-				return err
-			}
-			atomic.AddInt64(&size, n)
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		} else {
-			cmd.val = size
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptLoad(ctx context.Context, script string) *StringCmd {
-	cmd := NewStringCmd(ctx, "script", "load", script)
-	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		var mu sync.Mutex
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			val, err := shard.ScriptLoad(ctx, script).Result()
-			if err != nil {
-				return err
-			}
-
-			mu.Lock()
-			if cmd.Val() == "" {
-				cmd.val = val
-			}
-			mu.Unlock()
-
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptFlush(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "script", "flush")
-	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			return shard.ScriptFlush(ctx).Err()
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		}
-		return nil
-	})
-	return cmd
-}
-
-func (c *ClusterClient) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
-	args := make([]interface{}, 2+len(hashes))
-	args[0] = "script"
-	args[1] = "exists"
-	for i, hash := range hashes {
-		args[2+i] = hash
+import "context"
+
+type ClusterCmdable interface {
+	ClusterMyShardID(ctx context.Context) *StringCmd
+	ClusterSlots(ctx context.Context) *ClusterSlotsCmd
+	ClusterShards(ctx context.Context) *ClusterShardsCmd
+	ClusterLinks(ctx context.Context) *ClusterLinksCmd
+	ClusterNodes(ctx context.Context) *StringCmd
+	ClusterMeet(ctx context.Context, host, port string) *StatusCmd
+	ClusterForget(ctx context.Context, nodeID string) *StatusCmd
+	ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd
+	ClusterResetSoft(ctx context.Context) *StatusCmd
+	ClusterResetHard(ctx context.Context) *StatusCmd
+	ClusterInfo(ctx context.Context) *StringCmd
+	ClusterKeySlot(ctx context.Context, key string) *IntCmd
+	ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd
+	ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd
+	ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd
+	ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd
+	ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd
+	ClusterSaveConfig(ctx context.Context) *StatusCmd
+	ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd
+	ClusterFailover(ctx context.Context) *StatusCmd
+	ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd
+	ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd
+	ReadOnly(ctx context.Context) *StatusCmd
+	ReadWrite(ctx context.Context) *StatusCmd
+}
+
+func (c cmdable) ClusterMyShardID(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "cluster", "myshardid")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterSlots(ctx context.Context) *ClusterSlotsCmd {
+	cmd := NewClusterSlotsCmd(ctx, "cluster", "slots")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterShards(ctx context.Context) *ClusterShardsCmd {
+	cmd := NewClusterShardsCmd(ctx, "cluster", "shards")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterLinks(ctx context.Context) *ClusterLinksCmd {
+	cmd := NewClusterLinksCmd(ctx, "cluster", "links")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterNodes(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "cluster", "nodes")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterMeet(ctx context.Context, host, port string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "meet", host, port)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterForget(ctx context.Context, nodeID string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "forget", nodeID)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "replicate", nodeID)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterResetSoft(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "reset", "soft")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterResetHard(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "reset", "hard")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterInfo(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "cluster", "info")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterKeySlot(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "cluster", "keyslot", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "cluster", "getkeysinslot", slot, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd {
+	cmd := NewIntCmd(ctx, "cluster", "count-failure-reports", nodeID)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd {
+	cmd := NewIntCmd(ctx, "cluster", "countkeysinslot", slot)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd {
+	args := make([]interface{}, 2+len(slots))
+	args[0] = "cluster"
+	args[1] = "delslots"
+	for i, slot := range slots {
+		args[2+i] = slot
 	}
-	cmd := NewBoolSliceCmd(ctx, args...)
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
 
-	result := make([]bool, len(hashes))
-	for i := range result {
-		result[i] = true
+func (c cmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd {
+	size := max - min + 1
+	slots := make([]int, size)
+	for i := 0; i < size; i++ {
+		slots[i] = min + i
 	}
+	return c.ClusterDelSlots(ctx, slots...)
+}
+
+func (c cmdable) ClusterSaveConfig(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "saveconfig")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "cluster", "slaves", nodeID)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterFailover(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "cluster", "failover")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd {
+	args := make([]interface{}, 2+len(slots))
+	args[0] = "cluster"
+	args[1] = "addslots"
+	for i, num := range slots {
+		args[2+i] = num
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd {
+	size := max - min + 1
+	slots := make([]int, size)
+	for i := 0; i < size; i++ {
+		slots[i] = min + i
+	}
+	return c.ClusterAddSlots(ctx, slots...)
+}
+
+func (c cmdable) ReadOnly(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "readonly")
+	_ = c(ctx, cmd)
+	return cmd
+}
 
-	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
-		var mu sync.Mutex
-		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
-			val, err := shard.ScriptExists(ctx, hashes...).Result()
-			if err != nil {
-				return err
-			}
-
-			mu.Lock()
-			for i, v := range val {
-				result[i] = result[i] && v
-			}
-			mu.Unlock()
-
-			return nil
-		})
-		if err != nil {
-			cmd.SetErr(err)
-		} else {
-			cmd.val = result
-		}
-		return nil
-	})
+func (c cmdable) ReadWrite(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "readwrite")
+	_ = c(ctx, cmd)
 	return cmd
 }
diff --git a/command.go b/command.go
index b6df28fbe..c6cd9db6d 100644
--- a/command.go
+++ b/command.go
@@ -1,11 +1,14 @@
 package redis
 
 import (
+	"bufio"
 	"context"
 	"fmt"
 	"net"
+	"regexp"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/redis/go-redis/v9/internal"
@@ -15,10 +18,22 @@ import (
 )
 
 type Cmder interface {
+	// command name.
+	// e.g. "set k v ex 10" -> "set", "cluster info" -> "cluster".
 	Name() string
+
+	// full command name.
+	// e.g. "set k v ex 10" -> "set", "cluster info" -> "cluster info".
 	FullName() string
+
+	// all args of the command.
+	// e.g. "set k v ex 10" -> "[set k v ex 10]".
 	Args() []interface{}
+
+	// format request and response string.
+	// e.g. "set k v ex 10" -> "set k v ex 10: OK", "get k" -> "get k: v".
 	String() string
+
 	stringArg(int) string
 	firstKeyPos() int8
 	SetFirstKeyPos(int8)
@@ -60,7 +75,7 @@ func writeCmd(wr *proto.Writer, cmd Cmder) error {
 	return wr.WriteArgs(cmd.Args())
 }
 
-func cmdFirstKeyPos(cmd Cmder, info *CommandInfo) int {
+func cmdFirstKeyPos(cmd Cmder) int {
 	if pos := cmd.firstKeyPos(); pos != 0 {
 		return int(pos)
 	}
@@ -80,10 +95,6 @@ func cmdFirstKeyPos(cmd Cmder, info *CommandInfo) int {
 			return 2
 		}
 	}
-
-	if info != nil {
-		return int(info.FirstKeyPos)
-	}
 	return 1
 }
 
@@ -843,7 +854,7 @@ func (cmd *StringCmd) Val() string {
 }
 
 func (cmd *StringCmd) Result() (string, error) {
-	return cmd.Val(), cmd.err
+	return cmd.val, cmd.err
 }
 
 func (cmd *StringCmd) Bytes() ([]byte, error) {
@@ -947,7 +958,7 @@ func (cmd *FloatCmd) Val() float64 {
 }
 
 func (cmd *FloatCmd) Result() (float64, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *FloatCmd) String() string {
@@ -1042,7 +1053,7 @@ func (cmd *StringSliceCmd) Val() []string {
 }
 
 func (cmd *StringSliceCmd) Result() ([]string, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *StringSliceCmd) String() string {
@@ -1351,6 +1362,65 @@ func (cmd *MapStringIntCmd) readReply(rd *proto.Reader) error {
 	return nil
 }
 
+// ------------------------------------------------------------------------------
+type MapStringSliceInterfaceCmd struct {
+	baseCmd
+	val map[string][]interface{}
+}
+
+func NewMapStringSliceInterfaceCmd(ctx context.Context, args ...interface{}) *MapStringSliceInterfaceCmd {
+	return &MapStringSliceInterfaceCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *MapStringSliceInterfaceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *MapStringSliceInterfaceCmd) SetVal(val map[string][]interface{}) {
+	cmd.val = val
+}
+
+func (cmd *MapStringSliceInterfaceCmd) Result() (map[string][]interface{}, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *MapStringSliceInterfaceCmd) Val() map[string][]interface{} {
+	return cmd.val
+}
+
+func (cmd *MapStringSliceInterfaceCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+	cmd.val = make(map[string][]interface{}, n)
+	for i := 0; i < n; i++ {
+		k, err := rd.ReadString()
+		if err != nil {
+			return err
+		}
+		nn, err := rd.ReadArrayLen()
+		if err != nil {
+			return err
+		}
+		cmd.val[k] = make([]interface{}, nn)
+		for j := 0; j < nn; j++ {
+			value, err := rd.ReadReply()
+			if err != nil {
+				return err
+			}
+			cmd.val[k][j] = value
+		}
+	}
+
+	return nil
+}
+
 //------------------------------------------------------------------------------
 
 type StringStructMapCmd struct {
@@ -2645,7 +2715,7 @@ func (cmd *ZWithKeyCmd) Val() *ZWithKey {
 }
 
 func (cmd *ZWithKeyCmd) Result() (*ZWithKey, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *ZWithKeyCmd) String() string {
@@ -2783,7 +2853,7 @@ func (cmd *ClusterSlotsCmd) Val() []ClusterSlot {
 }
 
 func (cmd *ClusterSlotsCmd) Result() ([]ClusterSlot, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *ClusterSlotsCmd) String() string {
@@ -3243,7 +3313,7 @@ func (cmd *GeoPosCmd) Val() []*GeoPos {
 }
 
 func (cmd *GeoPosCmd) Result() ([]*GeoPos, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *GeoPosCmd) String() string {
@@ -3324,7 +3394,7 @@ func (cmd *CommandsInfoCmd) Val() map[string]*CommandInfo {
 }
 
 func (cmd *CommandsInfoCmd) Result() (map[string]*CommandInfo, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *CommandsInfoCmd) String() string {
@@ -3514,7 +3584,7 @@ func (cmd *SlowLogCmd) Val() []SlowLog {
 }
 
 func (cmd *SlowLogCmd) Result() ([]SlowLog, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *SlowLogCmd) String() string {
@@ -3613,7 +3683,7 @@ func (cmd *MapStringInterfaceCmd) Val() map[string]interface{} {
 }
 
 func (cmd *MapStringInterfaceCmd) Result() (map[string]interface{}, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *MapStringInterfaceCmd) String() string {
@@ -3677,7 +3747,7 @@ func (cmd *MapStringStringSliceCmd) Val() []map[string]string {
 }
 
 func (cmd *MapStringStringSliceCmd) Result() ([]map[string]string, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *MapStringStringSliceCmd) String() string {
@@ -3713,6 +3783,71 @@ func (cmd *MapStringStringSliceCmd) readReply(rd *proto.Reader) error {
 	return nil
 }
 
+//-----------------------------------------------------------------------
+
+type MapStringInterfaceSliceCmd struct {
+	baseCmd
+
+	val []map[string]interface{}
+}
+
+var _ Cmder = (*MapStringInterfaceSliceCmd)(nil)
+
+func NewMapStringInterfaceSliceCmd(ctx context.Context, args ...interface{}) *MapStringInterfaceSliceCmd {
+	return &MapStringInterfaceSliceCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *MapStringInterfaceSliceCmd) SetVal(val []map[string]interface{}) {
+	cmd.val = val
+}
+
+func (cmd *MapStringInterfaceSliceCmd) Val() []map[string]interface{} {
+	return cmd.val
+}
+
+func (cmd *MapStringInterfaceSliceCmd) Result() ([]map[string]interface{}, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *MapStringInterfaceSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *MapStringInterfaceSliceCmd) readReply(rd *proto.Reader) error {
+	n, err := rd.ReadArrayLen()
+	if err != nil {
+		return err
+	}
+
+	cmd.val = make([]map[string]interface{}, n)
+	for i := 0; i < n; i++ {
+		nn, err := rd.ReadMapLen()
+		if err != nil {
+			return err
+		}
+		cmd.val[i] = make(map[string]interface{}, nn)
+		for f := 0; f < nn; f++ {
+			k, err := rd.ReadString()
+			if err != nil {
+				return err
+			}
+			v, err := rd.ReadReply()
+			if err != nil {
+				if err != Nil {
+					return err
+				}
+			}
+			cmd.val[i][k] = v
+		}
+	}
+	return nil
+}
+
 //------------------------------------------------------------------------------
 
 type KeyValuesCmd struct {
@@ -4200,7 +4335,6 @@ func (cmd *FunctionStatsCmd) readDuration(rd *proto.Reader) (time.Duration, erro
 }
 
 func (cmd *FunctionStatsCmd) readCommand(rd *proto.Reader) ([]string, error) {
-
 	n, err := rd.ReadArrayLen()
 	if err != nil {
 		return nil, err
@@ -4217,6 +4351,7 @@ func (cmd *FunctionStatsCmd) readCommand(rd *proto.Reader) ([]string, error) {
 
 	return command, nil
 }
+
 func (cmd *FunctionStatsCmd) readRunningScripts(rd *proto.Reader) ([]RunningScript, bool, error) {
 	n, err := rd.ReadArrayLen()
 	if err != nil {
@@ -4526,7 +4661,7 @@ func (cmd *ClusterLinksCmd) Val() []ClusterLink {
 }
 
 func (cmd *ClusterLinksCmd) Result() ([]ClusterLink, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *ClusterLinksCmd) String() string {
@@ -4628,7 +4763,7 @@ func (cmd *ClusterShardsCmd) Val() []ClusterShard {
 }
 
 func (cmd *ClusterShardsCmd) Result() ([]ClusterShard, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *ClusterShardsCmd) String() string {
@@ -5101,7 +5236,7 @@ func (cmd *ACLLogCmd) Val() []*ACLLogEntry {
 }
 
 func (cmd *ACLLogCmd) Result() ([]*ACLLogEntry, error) {
-	return cmd.Val(), cmd.Err()
+	return cmd.val, cmd.err
 }
 
 func (cmd *ACLLogCmd) String() string {
@@ -5168,3 +5303,184 @@ func (cmd *ACLLogCmd) readReply(rd *proto.Reader) error {
 
 	return nil
 }
+
+// LibraryInfo holds the library info.
+type LibraryInfo struct {
+	LibName *string
+	LibVer  *string
+}
+
+// WithLibraryName returns a valid LibraryInfo with library name only.
+func WithLibraryName(libName string) LibraryInfo {
+	return LibraryInfo{LibName: &libName}
+}
+
+// WithLibraryVersion returns a valid LibraryInfo with library version only.
+func WithLibraryVersion(libVer string) LibraryInfo {
+	return LibraryInfo{LibVer: &libVer}
+}
+
+// -------------------------------------------
+
+type InfoCmd struct {
+	baseCmd
+	val map[string]map[string]string
+}
+
+var _ Cmder = (*InfoCmd)(nil)
+
+func NewInfoCmd(ctx context.Context, args ...interface{}) *InfoCmd {
+	return &InfoCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *InfoCmd) SetVal(val map[string]map[string]string) {
+	cmd.val = val
+}
+
+func (cmd *InfoCmd) Val() map[string]map[string]string {
+	return cmd.val
+}
+
+func (cmd *InfoCmd) Result() (map[string]map[string]string, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *InfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *InfoCmd) readReply(rd *proto.Reader) error {
+	val, err := rd.ReadString()
+	if err != nil {
+		return err
+	}
+
+	section := ""
+	scanner := bufio.NewScanner(strings.NewReader(val))
+	moduleRe := regexp.MustCompile(`module:name=(.+?),(.+)$`)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.HasPrefix(line, "#") {
+			if cmd.val == nil {
+				cmd.val = make(map[string]map[string]string)
+			}
+			section = strings.TrimPrefix(line, "# ")
+			cmd.val[section] = make(map[string]string)
+		} else if line != "" {
+			if section == "Modules" {
+				kv := moduleRe.FindStringSubmatch(line)
+				if len(kv) == 3 {
+					cmd.val[section][kv[1]] = kv[2]
+				}
+			} else {
+				kv := strings.SplitN(line, ":", 2)
+				if len(kv) == 2 {
+					cmd.val[section][kv[0]] = kv[1]
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+func (cmd *InfoCmd) Item(section, key string) string {
+	if cmd.val == nil {
+		return ""
+	} else if cmd.val[section] == nil {
+		return ""
+	} else {
+		return cmd.val[section][key]
+	}
+}
+
+type MonitorStatus int
+
+const (
+	monitorStatusIdle MonitorStatus = iota
+	monitorStatusStart
+	monitorStatusStop
+)
+
+type MonitorCmd struct {
+	baseCmd
+	ch     chan string
+	status MonitorStatus
+	mu     sync.Mutex
+}
+
+func newMonitorCmd(ctx context.Context, ch chan string) *MonitorCmd {
+	return &MonitorCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: []interface{}{"monitor"},
+		},
+		ch:     ch,
+		status: monitorStatusIdle,
+		mu:     sync.Mutex{},
+	}
+}
+
+func (cmd *MonitorCmd) String() string {
+	return cmdString(cmd, nil)
+}
+
+func (cmd *MonitorCmd) readReply(rd *proto.Reader) error {
+	ctx, cancel := context.WithCancel(cmd.ctx)
+	go func(ctx context.Context) {
+		for {
+			select {
+			case <-ctx.Done():
+				return
+			default:
+				err := cmd.readMonitor(rd, cancel)
+				if err != nil {
+					cmd.err = err
+					return
+				}
+			}
+		}
+	}(ctx)
+	return nil
+}
+
+func (cmd *MonitorCmd) readMonitor(rd *proto.Reader, cancel context.CancelFunc) error {
+	for {
+		cmd.mu.Lock()
+		st := cmd.status
+		pk, _ := rd.Peek(1)
+		cmd.mu.Unlock()
+		if len(pk) != 0 && st == monitorStatusStart {
+			cmd.mu.Lock()
+			line, err := rd.ReadString()
+			cmd.mu.Unlock()
+			if err != nil {
+				return err
+			}
+			cmd.ch <- line
+		}
+		if st == monitorStatusStop {
+			cancel()
+			break
+		}
+	}
+	return nil
+}
+
+func (cmd *MonitorCmd) Start() {
+	cmd.mu.Lock()
+	defer cmd.mu.Unlock()
+	cmd.status = monitorStatusStart
+}
+
+func (cmd *MonitorCmd) Stop() {
+	cmd.mu.Lock()
+	defer cmd.mu.Unlock()
+	cmd.status = monitorStatusStop
+}
diff --git a/commands.go b/commands.go
index 34f4d2c22..db5959446 100644
--- a/commands.go
+++ b/commands.go
@@ -4,9 +4,11 @@ import (
 	"context"
 	"encoding"
 	"errors"
+	"fmt"
 	"io"
 	"net"
 	"reflect"
+	"runtime"
 	"strings"
 	"time"
 
@@ -170,234 +172,7 @@ type Cmdable interface {
 	Echo(ctx context.Context, message interface{}) *StringCmd
 	Ping(ctx context.Context) *StatusCmd
 	Quit(ctx context.Context) *StatusCmd
-	Del(ctx context.Context, keys ...string) *IntCmd
 	Unlink(ctx context.Context, keys ...string) *IntCmd
-	Dump(ctx context.Context, key string) *StringCmd
-	Exists(ctx context.Context, keys ...string) *IntCmd
-	Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
-	ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
-	ExpireTime(ctx context.Context, key string) *DurationCmd
-	ExpireNX(ctx context.Context, key string, expiration time.Duration) *BoolCmd
-	ExpireXX(ctx context.Context, key string, expiration time.Duration) *BoolCmd
-	ExpireGT(ctx context.Context, key string, expiration time.Duration) *BoolCmd
-	ExpireLT(ctx context.Context, key string, expiration time.Duration) *BoolCmd
-	Keys(ctx context.Context, pattern string) *StringSliceCmd
-	Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd
-	Move(ctx context.Context, key string, db int) *BoolCmd
-	ObjectRefCount(ctx context.Context, key string) *IntCmd
-	ObjectEncoding(ctx context.Context, key string) *StringCmd
-	ObjectIdleTime(ctx context.Context, key string) *DurationCmd
-	Persist(ctx context.Context, key string) *BoolCmd
-	PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
-	PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
-	PExpireTime(ctx context.Context, key string) *DurationCmd
-	PTTL(ctx context.Context, key string) *DurationCmd
-	RandomKey(ctx context.Context) *StringCmd
-	Rename(ctx context.Context, key, newkey string) *StatusCmd
-	RenameNX(ctx context.Context, key, newkey string) *BoolCmd
-	Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
-	RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
-	Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd
-	SortRO(ctx context.Context, key string, sort *Sort) *StringSliceCmd
-	SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd
-	SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd
-	Touch(ctx context.Context, keys ...string) *IntCmd
-	TTL(ctx context.Context, key string) *DurationCmd
-	Type(ctx context.Context, key string) *StatusCmd
-	Append(ctx context.Context, key, value string) *IntCmd
-	Decr(ctx context.Context, key string) *IntCmd
-	DecrBy(ctx context.Context, key string, decrement int64) *IntCmd
-	Get(ctx context.Context, key string) *StringCmd
-	GetRange(ctx context.Context, key string, start, end int64) *StringCmd
-	GetSet(ctx context.Context, key string, value interface{}) *StringCmd
-	GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd
-	GetDel(ctx context.Context, key string) *StringCmd
-	Incr(ctx context.Context, key string) *IntCmd
-	IncrBy(ctx context.Context, key string, value int64) *IntCmd
-	IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd
-	MGet(ctx context.Context, keys ...string) *SliceCmd
-	MSet(ctx context.Context, values ...interface{}) *StatusCmd
-	MSetNX(ctx context.Context, values ...interface{}) *BoolCmd
-	Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
-	SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd
-	SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
-	SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
-	SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
-	SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd
-	StrLen(ctx context.Context, key string) *IntCmd
-	Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *IntCmd
-
-	GetBit(ctx context.Context, key string, offset int64) *IntCmd
-	SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd
-	BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd
-	BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd
-	BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd
-	BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd
-	BitOpNot(ctx context.Context, destKey string, key string) *IntCmd
-	BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd
-	BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *IntCmd
-	BitField(ctx context.Context, key string, args ...interface{}) *IntSliceCmd
-
-	Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd
-	ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd
-	SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
-	HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
-	ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
-
-	HDel(ctx context.Context, key string, fields ...string) *IntCmd
-	HExists(ctx context.Context, key, field string) *BoolCmd
-	HGet(ctx context.Context, key, field string) *StringCmd
-	HGetAll(ctx context.Context, key string) *MapStringStringCmd
-	HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd
-	HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd
-	HKeys(ctx context.Context, key string) *StringSliceCmd
-	HLen(ctx context.Context, key string) *IntCmd
-	HMGet(ctx context.Context, key string, fields ...string) *SliceCmd
-	HSet(ctx context.Context, key string, values ...interface{}) *IntCmd
-	HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd
-	HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd
-	HVals(ctx context.Context, key string) *StringSliceCmd
-	HRandField(ctx context.Context, key string, count int) *StringSliceCmd
-	HRandFieldWithValues(ctx context.Context, key string, count int) *KeyValueSliceCmd
-
-	BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
-	BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd
-	BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
-	BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd
-	LCS(ctx context.Context, q *LCSQuery) *LCSCmd
-	LIndex(ctx context.Context, key string, index int64) *StringCmd
-	LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd
-	LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd
-	LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd
-	LLen(ctx context.Context, key string) *IntCmd
-	LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd
-	LPop(ctx context.Context, key string) *StringCmd
-	LPopCount(ctx context.Context, key string, count int) *StringSliceCmd
-	LPos(ctx context.Context, key string, value string, args LPosArgs) *IntCmd
-	LPosCount(ctx context.Context, key string, value string, count int64, args LPosArgs) *IntSliceCmd
-	LPush(ctx context.Context, key string, values ...interface{}) *IntCmd
-	LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
-	LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
-	LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd
-	LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd
-	LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd
-	RPop(ctx context.Context, key string) *StringCmd
-	RPopCount(ctx context.Context, key string, count int) *StringSliceCmd
-	RPopLPush(ctx context.Context, source, destination string) *StringCmd
-	RPush(ctx context.Context, key string, values ...interface{}) *IntCmd
-	RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
-	LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd
-	BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *StringCmd
-
-	SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd
-	SCard(ctx context.Context, key string) *IntCmd
-	SDiff(ctx context.Context, keys ...string) *StringSliceCmd
-	SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
-	SInter(ctx context.Context, keys ...string) *StringSliceCmd
-	SInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
-	SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd
-	SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd
-	SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd
-	SMembers(ctx context.Context, key string) *StringSliceCmd
-	SMembersMap(ctx context.Context, key string) *StringStructMapCmd
-	SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd
-	SPop(ctx context.Context, key string) *StringCmd
-	SPopN(ctx context.Context, key string, count int64) *StringSliceCmd
-	SRandMember(ctx context.Context, key string) *StringCmd
-	SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd
-	SRem(ctx context.Context, key string, members ...interface{}) *IntCmd
-	SUnion(ctx context.Context, keys ...string) *StringSliceCmd
-	SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd
-
-	XAdd(ctx context.Context, a *XAddArgs) *StringCmd
-	XDel(ctx context.Context, stream string, ids ...string) *IntCmd
-	XLen(ctx context.Context, stream string) *IntCmd
-	XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd
-	XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd
-	XRevRange(ctx context.Context, stream string, start, stop string) *XMessageSliceCmd
-	XRevRangeN(ctx context.Context, stream string, start, stop string, count int64) *XMessageSliceCmd
-	XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd
-	XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd
-	XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd
-	XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd
-	XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd
-	XGroupDestroy(ctx context.Context, stream, group string) *IntCmd
-	XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
-	XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
-	XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd
-	XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd
-	XPending(ctx context.Context, stream, group string) *XPendingCmd
-	XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd
-	XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd
-	XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd
-	XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd
-	XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd
-	XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd
-	XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd
-	XTrimMinID(ctx context.Context, key string, minID string) *IntCmd
-	XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd
-	XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd
-	XInfoStream(ctx context.Context, key string) *XInfoStreamCmd
-	XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd
-	XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd
-
-	BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
-	BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
-	BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd
-
-	ZAdd(ctx context.Context, key string, members ...Z) *IntCmd
-	ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd
-	ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd
-	ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd
-	ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd
-	ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd
-	ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd
-	ZCard(ctx context.Context, key string) *IntCmd
-	ZCount(ctx context.Context, key, min, max string) *IntCmd
-	ZLexCount(ctx context.Context, key, min, max string) *IntCmd
-	ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd
-	ZInter(ctx context.Context, store *ZStore) *StringSliceCmd
-	ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd
-	ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
-	ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd
-	ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd
-	ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd
-	ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd
-	ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd
-	ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
-	ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
-	ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
-	ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
-	ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
-	ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd
-	ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd
-	ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd
-	ZRank(ctx context.Context, key, member string) *IntCmd
-	ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
-	ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd
-	ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd
-	ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd
-	ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd
-	ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
-	ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
-	ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
-	ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
-	ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
-	ZRevRank(ctx context.Context, key, member string) *IntCmd
-	ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
-	ZScore(ctx context.Context, key, member string) *FloatCmd
-	ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd
-	ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd
-	ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd
-	ZUnion(ctx context.Context, store ZStore) *StringSliceCmd
-	ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd
-	ZDiff(ctx context.Context, keys ...string) *StringSliceCmd
-	ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd
-	ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
-
-	PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd
-	PFCount(ctx context.Context, keys ...string) *IntCmd
-	PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd
 
 	BgRewriteAOF(ctx context.Context) *StatusCmd
 	BgSave(ctx context.Context) *StatusCmd
@@ -429,81 +204,28 @@ type Cmdable interface {
 	SlowLogGet(ctx context.Context, num int64) *SlowLogCmd
 	Time(ctx context.Context) *TimeCmd
 	DebugObject(ctx context.Context, key string) *StringCmd
-	ReadOnly(ctx context.Context) *StatusCmd
-	ReadWrite(ctx context.Context) *StatusCmd
 	MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd
 
-	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
-	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
-	EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
-	EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
-	ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
-	ScriptFlush(ctx context.Context) *StatusCmd
-	ScriptKill(ctx context.Context) *StatusCmd
-	ScriptLoad(ctx context.Context, script string) *StringCmd
-
-	FunctionLoad(ctx context.Context, code string) *StringCmd
-	FunctionLoadReplace(ctx context.Context, code string) *StringCmd
-	FunctionDelete(ctx context.Context, libName string) *StringCmd
-	FunctionFlush(ctx context.Context) *StringCmd
-	FunctionKill(ctx context.Context) *StringCmd
-	FunctionFlushAsync(ctx context.Context) *StringCmd
-	FunctionList(ctx context.Context, q FunctionListQuery) *FunctionListCmd
-	FunctionDump(ctx context.Context) *StringCmd
-	FunctionRestore(ctx context.Context, libDump string) *StringCmd
-	FunctionStats(ctx context.Context) *FunctionStatsCmd
-	FCall(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
-	FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
-	FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
-
-	Publish(ctx context.Context, channel string, message interface{}) *IntCmd
-	SPublish(ctx context.Context, channel string, message interface{}) *IntCmd
-	PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd
-	PubSubNumSub(ctx context.Context, channels ...string) *MapStringIntCmd
-	PubSubNumPat(ctx context.Context) *IntCmd
-	PubSubShardChannels(ctx context.Context, pattern string) *StringSliceCmd
-	PubSubShardNumSub(ctx context.Context, channels ...string) *MapStringIntCmd
-
-	ClusterMyShardID(ctx context.Context) *StringCmd
-	ClusterSlots(ctx context.Context) *ClusterSlotsCmd
-	ClusterShards(ctx context.Context) *ClusterShardsCmd
-	ClusterLinks(ctx context.Context) *ClusterLinksCmd
-	ClusterNodes(ctx context.Context) *StringCmd
-	ClusterMeet(ctx context.Context, host, port string) *StatusCmd
-	ClusterForget(ctx context.Context, nodeID string) *StatusCmd
-	ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd
-	ClusterResetSoft(ctx context.Context) *StatusCmd
-	ClusterResetHard(ctx context.Context) *StatusCmd
-	ClusterInfo(ctx context.Context) *StringCmd
-	ClusterKeySlot(ctx context.Context, key string) *IntCmd
-	ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd
-	ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd
-	ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd
-	ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd
-	ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd
-	ClusterSaveConfig(ctx context.Context) *StatusCmd
-	ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd
-	ClusterFailover(ctx context.Context) *StatusCmd
-	ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd
-	ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd
-
-	GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd
-	GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd
-	GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
-	GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd
-	GeoRadiusByMember(ctx context.Context, key, member string, query *GeoRadiusQuery) *GeoLocationCmd
-	GeoRadiusByMemberStore(ctx context.Context, key, member string, query *GeoRadiusQuery) *IntCmd
-	GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd
-	GeoSearchLocation(ctx context.Context, key string, q *GeoSearchLocationQuery) *GeoSearchLocationCmd
-	GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd
-	GeoDist(ctx context.Context, key string, member1, member2, unit string) *FloatCmd
-	GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd
-
-	ACLDryRun(ctx context.Context, username string, command ...interface{}) *StringCmd
-	ACLLog(ctx context.Context, count int64) *ACLLogCmd
-	ACLLogReset(ctx context.Context) *StatusCmd
-
 	ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd
+
+	ACLCmdable
+	BitMapCmdable
+	ClusterCmdable
+	GearsCmdable
+	GenericCmdable
+	GeoCmdable
+	HashCmdable
+	HyperLogLogCmdable
+	ListCmdable
+	ProbabilisticCmdable
+	PubSubCmdable
+	ScriptingFunctionsCmdable
+	SetCmdable
+	SortedSetCmdable
+	StringCmdable
+	StreamCmdable
+	TimeseriesCmdable
+	JSONCmdable
 }
 
 type StatefulCmdable interface {
@@ -513,6 +235,7 @@ type StatefulCmdable interface {
 	Select(ctx context.Context, index int) *StatusCmd
 	SwapDB(ctx context.Context, index1, index2 int) *StatusCmd
 	ClientSetName(ctx context.Context, name string) *BoolCmd
+	ClientSetInfo(ctx context.Context, info LibraryInfo) *StatusCmd
 	Hello(ctx context.Context, ver int, username, password, clientName string) *MapStringInterfaceCmd
 }
 
@@ -551,6 +274,13 @@ func (c cmdable) Wait(ctx context.Context, numSlaves int, timeout time.Duration)
 	return cmd
 }
 
+func (c cmdable) WaitAOF(ctx context.Context, numLocal, numSlaves int, timeout time.Duration) *IntCmd {
+	cmd := NewIntCmd(ctx, "waitAOF", numLocal, numSlaves, int(timeout/time.Millisecond))
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
 func (c statefulCmdable) Select(ctx context.Context, index int) *StatusCmd {
 	cmd := NewStatusCmd(ctx, "select", index)
 	_ = c(ctx, cmd)
@@ -570,9 +300,40 @@ func (c statefulCmdable) ClientSetName(ctx context.Context, name string) *BoolCm
 	return cmd
 }
 
+// ClientSetInfo sends a CLIENT SETINFO command with the provided info.
+func (c statefulCmdable) ClientSetInfo(ctx context.Context, info LibraryInfo) *StatusCmd {
+	err := info.Validate()
+	if err != nil {
+		panic(err.Error())
+	}
+
+	var cmd *StatusCmd
+	if info.LibName != nil {
+		libName := fmt.Sprintf("go-redis(%s,%s)", *info.LibName, internal.ReplaceSpaces(runtime.Version()))
+		cmd = NewStatusCmd(ctx, "client", "setinfo", "LIB-NAME", libName)
+	} else {
+		cmd = NewStatusCmd(ctx, "client", "setinfo", "LIB-VER", *info.LibVer)
+	}
+
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// Validate checks if only one field in the struct is non-nil.
+func (info LibraryInfo) Validate() error {
+	if info.LibName != nil && info.LibVer != nil {
+		return errors.New("both LibName and LibVer cannot be set at the same time")
+	}
+	if info.LibName == nil && info.LibVer == nil {
+		return errors.New("at least one of LibName and LibVer should be set")
+	}
+	return nil
+}
+
 // Hello Set the resp protocol used.
 func (c statefulCmdable) Hello(ctx context.Context,
-	ver int, username, password, clientName string) *MapStringInterfaceCmd {
+	ver int, username, password, clientName string,
+) *MapStringInterfaceCmd {
 	args := make([]interface{}, 0, 7)
 	args = append(args, "hello", ver)
 	if password != "" {
@@ -665,3303 +426,293 @@ func (c cmdable) Quit(_ context.Context) *StatusCmd {
 	panic("not implemented")
 }
 
-func (c cmdable) Del(ctx context.Context, keys ...string) *IntCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "del"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
+//------------------------------------------------------------------------------
+
+func (c cmdable) BgRewriteAOF(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "bgrewriteaof")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Unlink(ctx context.Context, keys ...string) *IntCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "unlink"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
+func (c cmdable) BgSave(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "bgsave")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Dump(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "dump", key)
+func (c cmdable) ClientKill(ctx context.Context, ipPort string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "client", "kill", ipPort)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Exists(ctx context.Context, keys ...string) *IntCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "exists"
+// ClientKillByFilter is new style syntax, while the ClientKill is old
+//
+//	CLIENT KILL <option> [value] ... <option> [value]
+func (c cmdable) ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "client"
+	args[1] = "kill"
 	for i, key := range keys {
-		args[1+i] = key
+		args[2+i] = key
 	}
 	cmd := NewIntCmd(ctx, args...)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
-	return c.expire(ctx, key, expiration, "")
-}
-
-func (c cmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
-	return c.expire(ctx, key, expiration, "NX")
-}
-
-func (c cmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
-	return c.expire(ctx, key, expiration, "XX")
-}
-
-func (c cmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
-	return c.expire(ctx, key, expiration, "GT")
-}
-
-func (c cmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
-	return c.expire(ctx, key, expiration, "LT")
-}
-
-func (c cmdable) expire(
-	ctx context.Context, key string, expiration time.Duration, mode string,
-) *BoolCmd {
-	args := make([]interface{}, 3, 4)
-	args[0] = "expire"
-	args[1] = key
-	args[2] = formatSec(ctx, expiration)
-	if mode != "" {
-		args = append(args, mode)
-	}
-
-	cmd := NewBoolCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "expireat", key, tm.Unix())
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ExpireTime(ctx context.Context, key string) *DurationCmd {
-	cmd := NewDurationCmd(ctx, time.Second, "expiretime", key)
+func (c cmdable) ClientList(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "client", "list")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Keys(ctx context.Context, pattern string) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "keys", pattern)
+func (c cmdable) ClientPause(ctx context.Context, dur time.Duration) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "client", "pause", formatMs(ctx, dur))
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd {
-	cmd := NewStatusCmd(
-		ctx,
-		"migrate",
-		host,
-		port,
-		key,
-		db,
-		formatMs(ctx, timeout),
-	)
-	cmd.setReadTimeout(timeout)
+func (c cmdable) ClientUnpause(ctx context.Context) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "client", "unpause")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Move(ctx context.Context, key string, db int) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "move", key, db)
+func (c cmdable) ClientID(ctx context.Context) *IntCmd {
+	cmd := NewIntCmd(ctx, "client", "id")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) ObjectRefCount(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "object", "refcount", key)
+func (c cmdable) ClientUnblock(ctx context.Context, id int64) *IntCmd {
+	cmd := NewIntCmd(ctx, "client", "unblock", id)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) ObjectEncoding(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "object", "encoding", key)
+func (c cmdable) ClientUnblockWithError(ctx context.Context, id int64) *IntCmd {
+	cmd := NewIntCmd(ctx, "client", "unblock", id, "error")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) ObjectIdleTime(ctx context.Context, key string) *DurationCmd {
-	cmd := NewDurationCmd(ctx, time.Second, "object", "idletime", key)
+func (c cmdable) ClientInfo(ctx context.Context) *ClientInfoCmd {
+	cmd := NewClientInfoCmd(ctx, "client", "info")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Persist(ctx context.Context, key string) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "persist", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
+// ------------------------------------------------------------------------------------------------
 
-func (c cmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "pexpire", key, formatMs(ctx, expiration))
+func (c cmdable) ConfigGet(ctx context.Context, parameter string) *MapStringStringCmd {
+	cmd := NewMapStringStringCmd(ctx, "config", "get", parameter)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
-	cmd := NewBoolCmd(
-		ctx,
-		"pexpireat",
-		key,
-		tm.UnixNano()/int64(time.Millisecond),
-	)
+func (c cmdable) ConfigResetStat(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "config", "resetstat")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) PExpireTime(ctx context.Context, key string) *DurationCmd {
-	cmd := NewDurationCmd(ctx, time.Millisecond, "pexpiretime", key)
+func (c cmdable) ConfigSet(ctx context.Context, parameter, value string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "config", "set", parameter, value)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) PTTL(ctx context.Context, key string) *DurationCmd {
-	cmd := NewDurationCmd(ctx, time.Millisecond, "pttl", key)
+func (c cmdable) ConfigRewrite(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "config", "rewrite")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) RandomKey(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "randomkey")
+func (c cmdable) DBSize(ctx context.Context) *IntCmd {
+	cmd := NewIntCmd(ctx, "dbsize")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Rename(ctx context.Context, key, newkey string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "rename", key, newkey)
+func (c cmdable) FlushAll(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "flushall")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) RenameNX(ctx context.Context, key, newkey string) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "renamenx", key, newkey)
+func (c cmdable) FlushAllAsync(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "flushall", "async")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
-	cmd := NewStatusCmd(
-		ctx,
-		"restore",
-		key,
-		formatMs(ctx, ttl),
-		value,
-	)
+func (c cmdable) FlushDB(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "flushdb")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
-	cmd := NewStatusCmd(
-		ctx,
-		"restore",
-		key,
-		formatMs(ctx, ttl),
-		value,
-		"replace",
-	)
+func (c cmdable) FlushDBAsync(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "flushdb", "async")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-type Sort struct {
-	By            string
-	Offset, Count int64
-	Get           []string
-	Order         string
-	Alpha         bool
-}
-
-func (sort *Sort) args(command, key string) []interface{} {
-	args := []interface{}{command, key}
-
-	if sort.By != "" {
-		args = append(args, "by", sort.By)
-	}
-	if sort.Offset != 0 || sort.Count != 0 {
-		args = append(args, "limit", sort.Offset, sort.Count)
-	}
-	for _, get := range sort.Get {
-		args = append(args, "get", get)
-	}
-	if sort.Order != "" {
-		args = append(args, sort.Order)
-	}
-	if sort.Alpha {
-		args = append(args, "alpha")
+func (c cmdable) Info(ctx context.Context, sections ...string) *StringCmd {
+	args := make([]interface{}, 1+len(sections))
+	args[0] = "info"
+	for i, section := range sections {
+		args[i+1] = section
 	}
-	return args
-}
-
-func (c cmdable) SortRO(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, sort.args("sort_ro", key)...)
+	cmd := NewStringCmd(ctx, args...)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, sort.args("sort", key)...)
+func (c cmdable) InfoMap(ctx context.Context, sections ...string) *InfoCmd {
+	args := make([]interface{}, 1+len(sections))
+	args[0] = "info"
+	for i, section := range sections {
+		args[i+1] = section
+	}
+	cmd := NewInfoCmd(ctx, args...)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd {
-	args := sort.args("sort", key)
-	if store != "" {
-		args = append(args, "store", store)
-	}
-	cmd := NewIntCmd(ctx, args...)
+func (c cmdable) LastSave(ctx context.Context) *IntCmd {
+	cmd := NewIntCmd(ctx, "lastsave")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd {
-	cmd := NewSliceCmd(ctx, sort.args("sort", key)...)
+func (c cmdable) Save(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "save")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) Touch(ctx context.Context, keys ...string) *IntCmd {
-	args := make([]interface{}, len(keys)+1)
-	args[0] = "touch"
-	for i, key := range keys {
-		args[i+1] = key
+func (c cmdable) shutdown(ctx context.Context, modifier string) *StatusCmd {
+	var args []interface{}
+	if modifier == "" {
+		args = []interface{}{"shutdown"}
+	} else {
+		args = []interface{}{"shutdown", modifier}
 	}
-	cmd := NewIntCmd(ctx, args...)
+	cmd := NewStatusCmd(ctx, args...)
 	_ = c(ctx, cmd)
+	if err := cmd.Err(); err != nil {
+		if err == io.EOF {
+			// Server quit as expected.
+			cmd.err = nil
+		}
+	} else {
+		// Server did not quit. String reply contains the reason.
+		cmd.err = errors.New(cmd.val)
+		cmd.val = ""
+	}
 	return cmd
 }
 
-func (c cmdable) TTL(ctx context.Context, key string) *DurationCmd {
-	cmd := NewDurationCmd(ctx, time.Second, "ttl", key)
-	_ = c(ctx, cmd)
-	return cmd
+func (c cmdable) Shutdown(ctx context.Context) *StatusCmd {
+	return c.shutdown(ctx, "")
 }
 
-func (c cmdable) Type(ctx context.Context, key string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "type", key)
-	_ = c(ctx, cmd)
-	return cmd
+func (c cmdable) ShutdownSave(ctx context.Context) *StatusCmd {
+	return c.shutdown(ctx, "save")
 }
 
-func (c cmdable) Append(ctx context.Context, key, value string) *IntCmd {
-	cmd := NewIntCmd(ctx, "append", key, value)
-	_ = c(ctx, cmd)
-	return cmd
+func (c cmdable) ShutdownNoSave(ctx context.Context) *StatusCmd {
+	return c.shutdown(ctx, "nosave")
 }
 
-func (c cmdable) Decr(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "decr", key)
+func (c cmdable) SlaveOf(ctx context.Context, host, port string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "slaveof", host, port)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) DecrBy(ctx context.Context, key string, decrement int64) *IntCmd {
-	cmd := NewIntCmd(ctx, "decrby", key, decrement)
+func (c cmdable) SlowLogGet(ctx context.Context, num int64) *SlowLogCmd {
+	cmd := NewSlowLogCmd(context.Background(), "slowlog", "get", num)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-// Get Redis `GET key` command. It returns redis.Nil error when key does not exist.
-func (c cmdable) Get(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "get", key)
-	_ = c(ctx, cmd)
-	return cmd
+func (c cmdable) Sync(_ context.Context) {
+	panic("not implemented")
 }
 
-func (c cmdable) GetRange(ctx context.Context, key string, start, end int64) *StringCmd {
-	cmd := NewStringCmd(ctx, "getrange", key, start, end)
+func (c cmdable) Time(ctx context.Context) *TimeCmd {
+	cmd := NewTimeCmd(ctx, "time")
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) GetSet(ctx context.Context, key string, value interface{}) *StringCmd {
-	cmd := NewStringCmd(ctx, "getset", key, value)
+func (c cmdable) DebugObject(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "debug", "object", key)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-// GetEx An expiration of zero removes the TTL associated with the key (i.e. GETEX key persist).
-// Requires Redis >= 6.2.0.
-func (c cmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd {
-	args := make([]interface{}, 0, 4)
-	args = append(args, "getex", key)
-	if expiration > 0 {
-		if usePrecise(expiration) {
-			args = append(args, "px", formatMs(ctx, expiration))
-		} else {
-			args = append(args, "ex", formatSec(ctx, expiration))
+func (c cmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd {
+	args := []interface{}{"memory", "usage", key}
+	if len(samples) > 0 {
+		if len(samples) != 1 {
+			panic("MemoryUsage expects single sample count")
 		}
-	} else if expiration == 0 {
-		args = append(args, "persist")
+		args = append(args, "SAMPLES", samples[0])
 	}
-
-	cmd := NewStringCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// GetDel redis-server version >= 6.2.0.
-func (c cmdable) GetDel(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "getdel", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) Incr(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "incr", key)
+	cmd := NewIntCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-func (c cmdable) IncrBy(ctx context.Context, key string, value int64) *IntCmd {
-	cmd := NewIntCmd(ctx, "incrby", key, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
+//------------------------------------------------------------------------------
 
-func (c cmdable) IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd {
-	cmd := NewFloatCmd(ctx, "incrbyfloat", key, value)
-	_ = c(ctx, cmd)
-	return cmd
+// ModuleLoadexConfig struct is used to specify the arguments for the MODULE LOADEX command of redis.
+// `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]`
+type ModuleLoadexConfig struct {
+	Path string
+	Conf map[string]interface{}
+	Args []interface{}
 }
 
-func (c cmdable) MGet(ctx context.Context, keys ...string) *SliceCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "mget"
-	for i, key := range keys {
-		args[1+i] = key
+func (c *ModuleLoadexConfig) toArgs() []interface{} {
+	args := make([]interface{}, 3, 3+len(c.Conf)*3+len(c.Args)*2)
+	args[0] = "MODULE"
+	args[1] = "LOADEX"
+	args[2] = c.Path
+	for k, v := range c.Conf {
+		args = append(args, "CONFIG", k, v)
 	}
-	cmd := NewSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// MSet is like Set but accepts multiple values:
-//   - MSet("key1", "value1", "key2", "value2")
-//   - MSet([]string{"key1", "value1", "key2", "value2"})
-//   - MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})
-//   - MSet(struct), For struct types, see HSet description.
-func (c cmdable) MSet(ctx context.Context, values ...interface{}) *StatusCmd {
-	args := make([]interface{}, 1, 1+len(values))
-	args[0] = "mset"
-	args = appendArgs(args, values)
-	cmd := NewStatusCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// MSetNX is like SetNX but accepts multiple values:
-//   - MSetNX("key1", "value1", "key2", "value2")
-//   - MSetNX([]string{"key1", "value1", "key2", "value2"})
-//   - MSetNX(map[string]interface{}{"key1": "value1", "key2": "value2"})
-//   - MSetNX(struct), For struct types, see HSet description.
-func (c cmdable) MSetNX(ctx context.Context, values ...interface{}) *BoolCmd {
-	args := make([]interface{}, 1, 1+len(values))
-	args[0] = "msetnx"
-	args = appendArgs(args, values)
-	cmd := NewBoolCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// Set Redis `SET key value [expiration]` command.
-// Use expiration for `SETEx`-like behavior.
-//
-// Zero expiration means the key has no expiration time.
-// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
-// otherwise you will receive an error: (error) ERR syntax error.
-func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
-	args := make([]interface{}, 3, 5)
-	args[0] = "set"
-	args[1] = key
-	args[2] = value
-	if expiration > 0 {
-		if usePrecise(expiration) {
-			args = append(args, "px", formatMs(ctx, expiration))
-		} else {
-			args = append(args, "ex", formatSec(ctx, expiration))
-		}
-	} else if expiration == KeepTTL {
-		args = append(args, "keepttl")
+	for _, arg := range c.Args {
+		args = append(args, "ARGS", arg)
 	}
-
-	cmd := NewStatusCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SetArgs provides arguments for the SetArgs function.
-type SetArgs struct {
-	// Mode can be `NX` or `XX` or empty.
-	Mode string
-
-	// Zero `TTL` or `Expiration` means that the key has no expiration time.
-	TTL      time.Duration
-	ExpireAt time.Time
-
-	// When Get is true, the command returns the old value stored at key, or nil when key did not exist.
-	Get bool
-
-	// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
-	// otherwise you will receive an error: (error) ERR syntax error.
-	KeepTTL bool
+	return args
 }
 
-// SetArgs supports all the options that the SET command supports.
-// It is the alternative to the Set function when you want
-// to have more control over the options.
-func (c cmdable) SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd {
-	args := []interface{}{"set", key, value}
-
-	if a.KeepTTL {
-		args = append(args, "keepttl")
-	}
-
-	if !a.ExpireAt.IsZero() {
-		args = append(args, "exat", a.ExpireAt.Unix())
-	}
-	if a.TTL > 0 {
-		if usePrecise(a.TTL) {
-			args = append(args, "px", formatMs(ctx, a.TTL))
-		} else {
-			args = append(args, "ex", formatSec(ctx, a.TTL))
-		}
-	}
-
-	if a.Mode != "" {
-		args = append(args, a.Mode)
-	}
-
-	if a.Get {
-		args = append(args, "get")
-	}
-
-	cmd := NewStatusCmd(ctx, args...)
+// ModuleLoadex Redis `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]` command.
+func (c cmdable) ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd {
+	cmd := NewStringCmd(ctx, conf.toArgs()...)
 	_ = c(ctx, cmd)
 	return cmd
 }
 
-// SetEx Redis `SETEx key expiration value` command.
-func (c cmdable) SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "setex", key, formatSec(ctx, expiration), value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SetNX Redis `SET key value [expiration] NX` command.
-//
-// Zero expiration means the key has no expiration time.
-// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
-// otherwise you will receive an error: (error) ERR syntax error.
-func (c cmdable) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
-	var cmd *BoolCmd
-	switch expiration {
-	case 0:
-		// Use old `SETNX` to support old Redis versions.
-		cmd = NewBoolCmd(ctx, "setnx", key, value)
-	case KeepTTL:
-		cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "nx")
-	default:
-		if usePrecise(expiration) {
-			cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "nx")
-		} else {
-			cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "nx")
-		}
-	}
-
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SetXX Redis `SET key value [expiration] XX` command.
-//
-// Zero expiration means the key has no expiration time.
-// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
-// otherwise you will receive an error: (error) ERR syntax error.
-func (c cmdable) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
-	var cmd *BoolCmd
-	switch expiration {
-	case 0:
-		cmd = NewBoolCmd(ctx, "set", key, value, "xx")
-	case KeepTTL:
-		cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "xx")
-	default:
-		if usePrecise(expiration) {
-			cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "xx")
-		} else {
-			cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "xx")
-		}
-	}
-
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd {
-	cmd := NewIntCmd(ctx, "setrange", key, offset, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) StrLen(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "strlen", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *IntCmd {
-	args := []interface{}{"copy", sourceKey, destKey, "DB", db}
-	if replace {
-		args = append(args, "REPLACE")
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) GetBit(ctx context.Context, key string, offset int64) *IntCmd {
-	cmd := NewIntCmd(ctx, "getbit", key, offset)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SetBit(ctx context.Context, key string, offset int64, value int) *IntCmd {
-	cmd := NewIntCmd(
-		ctx,
-		"setbit",
-		key,
-		offset,
-		value,
-	)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-type BitCount struct {
-	Start, End int64
-}
-
-func (c cmdable) BitCount(ctx context.Context, key string, bitCount *BitCount) *IntCmd {
-	args := []interface{}{"bitcount", key}
-	if bitCount != nil {
-		args = append(
-			args,
-			bitCount.Start,
-			bitCount.End,
-		)
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) bitOp(ctx context.Context, op, destKey string, keys ...string) *IntCmd {
-	args := make([]interface{}, 3+len(keys))
-	args[0] = "bitop"
-	args[1] = op
-	args[2] = destKey
-	for i, key := range keys {
-		args[3+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BitOpAnd(ctx context.Context, destKey string, keys ...string) *IntCmd {
-	return c.bitOp(ctx, "and", destKey, keys...)
-}
-
-func (c cmdable) BitOpOr(ctx context.Context, destKey string, keys ...string) *IntCmd {
-	return c.bitOp(ctx, "or", destKey, keys...)
-}
-
-func (c cmdable) BitOpXor(ctx context.Context, destKey string, keys ...string) *IntCmd {
-	return c.bitOp(ctx, "xor", destKey, keys...)
-}
-
-func (c cmdable) BitOpNot(ctx context.Context, destKey string, key string) *IntCmd {
-	return c.bitOp(ctx, "not", destKey, key)
-}
-
-// BitPos is an API before Redis version 7.0, cmd: bitpos key bit start end
-// if you need the `byte | bit` parameter, please use `BitPosSpan`.
-func (c cmdable) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *IntCmd {
-	args := make([]interface{}, 3+len(pos))
-	args[0] = "bitpos"
-	args[1] = key
-	args[2] = bit
-	switch len(pos) {
-	case 0:
-	case 1:
-		args[3] = pos[0]
-	case 2:
-		args[3] = pos[0]
-		args[4] = pos[1]
-	default:
-		panic("too many arguments")
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// BitPosSpan supports the `byte | bit` parameters in redis version 7.0,
-// the bitpos command defaults to using byte type for the `start-end` range,
-// which means it counts in bytes from start to end. you can set the value
-// of "span" to determine the type of `start-end`.
-// span = "bit", cmd: bitpos key bit start end bit
-// span = "byte", cmd: bitpos key bit start end byte
-func (c cmdable) BitPosSpan(ctx context.Context, key string, bit int8, start, end int64, span string) *IntCmd {
-	cmd := NewIntCmd(ctx, "bitpos", key, bit, start, end, span)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BitField(ctx context.Context, key string, args ...interface{}) *IntSliceCmd {
-	a := make([]interface{}, 0, 2+len(args))
-	a = append(a, "bitfield")
-	a = append(a, key)
-	a = append(a, args...)
-	cmd := NewIntSliceCmd(ctx, a...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd {
-	args := []interface{}{"scan", cursor}
-	if match != "" {
-		args = append(args, "match", match)
-	}
-	if count > 0 {
-		args = append(args, "count", count)
-	}
-	cmd := NewScanCmd(ctx, c, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd {
-	args := []interface{}{"scan", cursor}
-	if match != "" {
-		args = append(args, "match", match)
-	}
-	if count > 0 {
-		args = append(args, "count", count)
-	}
-	if keyType != "" {
-		args = append(args, "type", keyType)
-	}
-	cmd := NewScanCmd(ctx, c, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
-	args := []interface{}{"sscan", key, cursor}
-	if match != "" {
-		args = append(args, "match", match)
-	}
-	if count > 0 {
-		args = append(args, "count", count)
-	}
-	cmd := NewScanCmd(ctx, c, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
-	args := []interface{}{"hscan", key, cursor}
-	if match != "" {
-		args = append(args, "match", match)
-	}
-	if count > 0 {
-		args = append(args, "count", count)
-	}
-	cmd := NewScanCmd(ctx, c, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
-	args := []interface{}{"zscan", key, cursor}
-	if match != "" {
-		args = append(args, "match", match)
-	}
-	if count > 0 {
-		args = append(args, "count", count)
-	}
-	cmd := NewScanCmd(ctx, c, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) HDel(ctx context.Context, key string, fields ...string) *IntCmd {
-	args := make([]interface{}, 2+len(fields))
-	args[0] = "hdel"
-	args[1] = key
-	for i, field := range fields {
-		args[2+i] = field
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HExists(ctx context.Context, key, field string) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "hexists", key, field)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HGet(ctx context.Context, key, field string) *StringCmd {
-	cmd := NewStringCmd(ctx, "hget", key, field)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HGetAll(ctx context.Context, key string) *MapStringStringCmd {
-	cmd := NewMapStringStringCmd(ctx, "hgetall", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd {
-	cmd := NewIntCmd(ctx, "hincrby", key, field, incr)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd {
-	cmd := NewFloatCmd(ctx, "hincrbyfloat", key, field, incr)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HKeys(ctx context.Context, key string) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "hkeys", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HLen(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "hlen", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// HMGet returns the values for the specified fields in the hash stored at key.
-// It returns an interface{} to distinguish between empty string and nil value.
-func (c cmdable) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd {
-	args := make([]interface{}, 2+len(fields))
-	args[0] = "hmget"
-	args[1] = key
-	for i, field := range fields {
-		args[2+i] = field
-	}
-	cmd := NewSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// HSet accepts values in following formats:
-//
-//   - HSet("myhash", "key1", "value1", "key2", "value2")
-//
-//   - HSet("myhash", []string{"key1", "value1", "key2", "value2"})
-//
-//   - HSet("myhash", map[string]interface{}{"key1": "value1", "key2": "value2"})
-//
-//     Playing struct With "redis" tag.
-//     type MyHash struct { Key1 string `redis:"key1"`; Key2 int `redis:"key2"` }
-//
-//   - HSet("myhash", MyHash{"value1", "value2"}) Warn: redis-server >= 4.0
-//
-//     For struct, can be a structure pointer type, we only parse the field whose tag is redis.
-//     if you don't want the field to be read, you can use the `redis:"-"` flag to ignore it,
-//     or you don't need to set the redis tag.
-//     For the type of structure field, we only support simple data types:
-//     string, int/uint(8,16,32,64), float(32,64), time.Time(to RFC3339Nano), time.Duration(to Nanoseconds ),
-//     if you are other more complex or custom data types, please implement the encoding.BinaryMarshaler interface.
-//
-// Note that in older versions of Redis server(redis-server < 4.0), HSet only supports a single key-value pair.
-// redis-docs: https://redis.io/commands/hset (Starting with Redis version 4.0.0: Accepts multiple field and value arguments.)
-// If you are using a Struct type and the number of fields is greater than one,
-// you will receive an error similar to "ERR wrong number of arguments", you can use HMSet as a substitute.
-func (c cmdable) HSet(ctx context.Context, key string, values ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(values))
-	args[0] = "hset"
-	args[1] = key
-	args = appendArgs(args, values)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// HMSet is a deprecated version of HSet left for compatibility with Redis 3.
-func (c cmdable) HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd {
-	args := make([]interface{}, 2, 2+len(values))
-	args[0] = "hmset"
-	args[1] = key
-	args = appendArgs(args, values)
-	cmd := NewBoolCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "hsetnx", key, field, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) HVals(ctx context.Context, key string) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "hvals", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// HRandField redis-server version >= 6.2.0.
-func (c cmdable) HRandField(ctx context.Context, key string, count int) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "hrandfield", key, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// HRandFieldWithValues redis-server version >= 6.2.0.
-func (c cmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *KeyValueSliceCmd {
-	cmd := NewKeyValueSliceCmd(ctx, "hrandfield", key, count, "withvalues")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
-	args := make([]interface{}, 1+len(keys)+1)
-	args[0] = "blpop"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	args[len(args)-1] = formatSec(ctx, timeout)
-	cmd := NewStringSliceCmd(ctx, args...)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd {
-	args := make([]interface{}, 3+len(keys), 6+len(keys))
-	args[0] = "blmpop"
-	args[1] = formatSec(ctx, timeout)
-	args[2] = len(keys)
-	for i, key := range keys {
-		args[3+i] = key
-	}
-	args = append(args, strings.ToLower(direction), "count", count)
-	cmd := NewKeyValuesCmd(ctx, args...)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
-	args := make([]interface{}, 1+len(keys)+1)
-	args[0] = "brpop"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	args[len(keys)+1] = formatSec(ctx, timeout)
-	cmd := NewStringSliceCmd(ctx, args...)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd {
-	cmd := NewStringCmd(
-		ctx,
-		"brpoplpush",
-		source,
-		destination,
-		formatSec(ctx, timeout),
-	)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LCS(ctx context.Context, q *LCSQuery) *LCSCmd {
-	cmd := NewLCSCmd(ctx, q)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LIndex(ctx context.Context, key string, index int64) *StringCmd {
-	cmd := NewStringCmd(ctx, "lindex", key, index)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// LMPop Pops one or more elements from the first non-empty list key from the list of provided key names.
-// direction: left or right, count: > 0
-// example: client.LMPop(ctx, "left", 3, "key1", "key2")
-func (c cmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd {
-	args := make([]interface{}, 2+len(keys), 5+len(keys))
-	args[0] = "lmpop"
-	args[1] = len(keys)
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	args = append(args, strings.ToLower(direction), "count", count)
-	cmd := NewKeyValuesCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd {
-	cmd := NewIntCmd(ctx, "linsert", key, op, pivot, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
-	cmd := NewIntCmd(ctx, "linsert", key, "before", pivot, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
-	cmd := NewIntCmd(ctx, "linsert", key, "after", pivot, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LLen(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "llen", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LPop(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "lpop", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LPopCount(ctx context.Context, key string, count int) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "lpop", key, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-type LPosArgs struct {
-	Rank, MaxLen int64
-}
-
-func (c cmdable) LPos(ctx context.Context, key string, value string, a LPosArgs) *IntCmd {
-	args := []interface{}{"lpos", key, value}
-	if a.Rank != 0 {
-		args = append(args, "rank", a.Rank)
-	}
-	if a.MaxLen != 0 {
-		args = append(args, "maxlen", a.MaxLen)
-	}
-
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LPosCount(ctx context.Context, key string, value string, count int64, a LPosArgs) *IntSliceCmd {
-	args := []interface{}{"lpos", key, value, "count", count}
-	if a.Rank != 0 {
-		args = append(args, "rank", a.Rank)
-	}
-	if a.MaxLen != 0 {
-		args = append(args, "maxlen", a.MaxLen)
-	}
-	cmd := NewIntSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(values))
-	args[0] = "lpush"
-	args[1] = key
-	args = appendArgs(args, values)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(values))
-	args[0] = "lpushx"
-	args[1] = key
-	args = appendArgs(args, values)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
-	cmd := NewStringSliceCmd(
-		ctx,
-		"lrange",
-		key,
-		start,
-		stop,
-	)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd {
-	cmd := NewIntCmd(ctx, "lrem", key, count, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "lset", key, index, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd {
-	cmd := NewStatusCmd(
-		ctx,
-		"ltrim",
-		key,
-		start,
-		stop,
-	)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) RPop(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "rpop", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) RPopCount(ctx context.Context, key string, count int) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "rpop", key, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) RPopLPush(ctx context.Context, source, destination string) *StringCmd {
-	cmd := NewStringCmd(ctx, "rpoplpush", source, destination)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) RPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(values))
-	args[0] = "rpush"
-	args[1] = key
-	args = appendArgs(args, values)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(values))
-	args[0] = "rpushx"
-	args[1] = key
-	args = appendArgs(args, values)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd {
-	cmd := NewStringCmd(ctx, "lmove", source, destination, srcpos, destpos)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BLMove(
-	ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration,
-) *StringCmd {
-	cmd := NewStringCmd(ctx, "blmove", source, destination, srcpos, destpos, formatSec(ctx, timeout))
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(members))
-	args[0] = "sadd"
-	args[1] = key
-	args = appendArgs(args, members)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SCard(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "scard", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SDiff(ctx context.Context, keys ...string) *StringSliceCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "sdiff"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
-	args := make([]interface{}, 2+len(keys))
-	args[0] = "sdiffstore"
-	args[1] = destination
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SInter(ctx context.Context, keys ...string) *StringSliceCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "sinter"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd {
-	args := make([]interface{}, 4+len(keys))
-	args[0] = "sintercard"
-	numkeys := int64(0)
-	for i, key := range keys {
-		args[2+i] = key
-		numkeys++
-	}
-	args[1] = numkeys
-	args[2+numkeys] = "limit"
-	args[3+numkeys] = limit
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd {
-	args := make([]interface{}, 2+len(keys))
-	args[0] = "sinterstore"
-	args[1] = destination
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "sismember", key, member)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SMIsMember Redis `SMISMEMBER key member [member ...]` command.
-func (c cmdable) SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd {
-	args := make([]interface{}, 2, 2+len(members))
-	args[0] = "smismember"
-	args[1] = key
-	args = appendArgs(args, members)
-	cmd := NewBoolSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SMembers Redis `SMEMBERS key` command output as a slice.
-func (c cmdable) SMembers(ctx context.Context, key string) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "smembers", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SMembersMap Redis `SMEMBERS key` command output as a map.
-func (c cmdable) SMembersMap(ctx context.Context, key string) *StringStructMapCmd {
-	cmd := NewStringStructMapCmd(ctx, "smembers", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "smove", source, destination, member)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SPop Redis `SPOP key` command.
-func (c cmdable) SPop(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "spop", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SPopN Redis `SPOP key count` command.
-func (c cmdable) SPopN(ctx context.Context, key string, count int64) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "spop", key, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SRandMember Redis `SRANDMEMBER key` command.
-func (c cmdable) SRandMember(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "srandmember", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// SRandMemberN Redis `SRANDMEMBER key count` command.
-func (c cmdable) SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "srandmember", key, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(members))
-	args[0] = "srem"
-	args[1] = key
-	args = appendArgs(args, members)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SUnion(ctx context.Context, keys ...string) *StringSliceCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "sunion"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd {
-	args := make([]interface{}, 2+len(keys))
-	args[0] = "sunionstore"
-	args[1] = destination
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-// XAddArgs accepts values in the following formats:
-//   - XAddArgs.Values = []interface{}{"key1", "value1", "key2", "value2"}
-//   - XAddArgs.Values = []string("key1", "value1", "key2", "value2")
-//   - XAddArgs.Values = map[string]interface{}{"key1": "value1", "key2": "value2"}
-//
-// Note that map will not preserve the order of key-value pairs.
-// MaxLen/MaxLenApprox and MinID are in conflict, only one of them can be used.
-type XAddArgs struct {
-	Stream     string
-	NoMkStream bool
-	MaxLen     int64 // MAXLEN N
-	MinID      string
-	// Approx causes MaxLen and MinID to use "~" matcher (instead of "=").
-	Approx bool
-	Limit  int64
-	ID     string
-	Values interface{}
-}
-
-func (c cmdable) XAdd(ctx context.Context, a *XAddArgs) *StringCmd {
-	args := make([]interface{}, 0, 11)
-	args = append(args, "xadd", a.Stream)
-	if a.NoMkStream {
-		args = append(args, "nomkstream")
-	}
-	switch {
-	case a.MaxLen > 0:
-		if a.Approx {
-			args = append(args, "maxlen", "~", a.MaxLen)
-		} else {
-			args = append(args, "maxlen", a.MaxLen)
-		}
-	case a.MinID != "":
-		if a.Approx {
-			args = append(args, "minid", "~", a.MinID)
-		} else {
-			args = append(args, "minid", a.MinID)
-		}
-	}
-	if a.Limit > 0 {
-		args = append(args, "limit", a.Limit)
-	}
-	if a.ID != "" {
-		args = append(args, a.ID)
-	} else {
-		args = append(args, "*")
-	}
-	args = appendArg(args, a.Values)
-
-	cmd := NewStringCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XDel(ctx context.Context, stream string, ids ...string) *IntCmd {
-	args := []interface{}{"xdel", stream}
-	for _, id := range ids {
-		args = append(args, id)
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XLen(ctx context.Context, stream string) *IntCmd {
-	cmd := NewIntCmd(ctx, "xlen", stream)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
-	cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
-	cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop, "count", count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XRevRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
-	cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
-	cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop, "count", count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-type XReadArgs struct {
-	Streams []string // list of streams and ids, e.g. stream1 stream2 id1 id2
-	Count   int64
-	Block   time.Duration
-}
-
-func (c cmdable) XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd {
-	args := make([]interface{}, 0, 6+len(a.Streams))
-	args = append(args, "xread")
-
-	keyPos := int8(1)
-	if a.Count > 0 {
-		args = append(args, "count")
-		args = append(args, a.Count)
-		keyPos += 2
-	}
-	if a.Block >= 0 {
-		args = append(args, "block")
-		args = append(args, int64(a.Block/time.Millisecond))
-		keyPos += 2
-	}
-	args = append(args, "streams")
-	keyPos++
-	for _, s := range a.Streams {
-		args = append(args, s)
-	}
-
-	cmd := NewXStreamSliceCmd(ctx, args...)
-	if a.Block >= 0 {
-		cmd.setReadTimeout(a.Block)
-	}
-	cmd.SetFirstKeyPos(keyPos)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd {
-	return c.XRead(ctx, &XReadArgs{
-		Streams: streams,
-		Block:   -1,
-	})
-}
-
-func (c cmdable) XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start, "mkstream")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "xgroup", "setid", stream, group, start)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XGroupDestroy(ctx context.Context, stream, group string) *IntCmd {
-	cmd := NewIntCmd(ctx, "xgroup", "destroy", stream, group)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
-	cmd := NewIntCmd(ctx, "xgroup", "createconsumer", stream, group, consumer)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
-	cmd := NewIntCmd(ctx, "xgroup", "delconsumer", stream, group, consumer)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-type XReadGroupArgs struct {
-	Group    string
-	Consumer string
-	Streams  []string // list of streams and ids, e.g. stream1 stream2 id1 id2
-	Count    int64
-	Block    time.Duration
-	NoAck    bool
-}
-
-func (c cmdable) XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd {
-	args := make([]interface{}, 0, 10+len(a.Streams))
-	args = append(args, "xreadgroup", "group", a.Group, a.Consumer)
-
-	keyPos := int8(4)
-	if a.Count > 0 {
-		args = append(args, "count", a.Count)
-		keyPos += 2
-	}
-	if a.Block >= 0 {
-		args = append(args, "block", int64(a.Block/time.Millisecond))
-		keyPos += 2
-	}
-	if a.NoAck {
-		args = append(args, "noack")
-		keyPos++
-	}
-	args = append(args, "streams")
-	keyPos++
-	for _, s := range a.Streams {
-		args = append(args, s)
-	}
-
-	cmd := NewXStreamSliceCmd(ctx, args...)
-	if a.Block >= 0 {
-		cmd.setReadTimeout(a.Block)
-	}
-	cmd.SetFirstKeyPos(keyPos)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd {
-	args := []interface{}{"xack", stream, group}
-	for _, id := range ids {
-		args = append(args, id)
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XPending(ctx context.Context, stream, group string) *XPendingCmd {
-	cmd := NewXPendingCmd(ctx, "xpending", stream, group)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-type XPendingExtArgs struct {
-	Stream   string
-	Group    string
-	Idle     time.Duration
-	Start    string
-	End      string
-	Count    int64
-	Consumer string
-}
-
-func (c cmdable) XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd {
-	args := make([]interface{}, 0, 9)
-	args = append(args, "xpending", a.Stream, a.Group)
-	if a.Idle != 0 {
-		args = append(args, "idle", formatMs(ctx, a.Idle))
-	}
-	args = append(args, a.Start, a.End, a.Count)
-	if a.Consumer != "" {
-		args = append(args, a.Consumer)
-	}
-	cmd := NewXPendingExtCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-type XAutoClaimArgs struct {
-	Stream   string
-	Group    string
-	MinIdle  time.Duration
-	Start    string
-	Count    int64
-	Consumer string
-}
-
-func (c cmdable) XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd {
-	args := xAutoClaimArgs(ctx, a)
-	cmd := NewXAutoClaimCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd {
-	args := xAutoClaimArgs(ctx, a)
-	args = append(args, "justid")
-	cmd := NewXAutoClaimJustIDCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func xAutoClaimArgs(ctx context.Context, a *XAutoClaimArgs) []interface{} {
-	args := make([]interface{}, 0, 8)
-	args = append(args, "xautoclaim", a.Stream, a.Group, a.Consumer, formatMs(ctx, a.MinIdle), a.Start)
-	if a.Count > 0 {
-		args = append(args, "count", a.Count)
-	}
-	return args
-}
-
-type XClaimArgs struct {
-	Stream   string
-	Group    string
-	Consumer string
-	MinIdle  time.Duration
-	Messages []string
-}
-
-func (c cmdable) XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd {
-	args := xClaimArgs(a)
-	cmd := NewXMessageSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd {
-	args := xClaimArgs(a)
-	args = append(args, "justid")
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func xClaimArgs(a *XClaimArgs) []interface{} {
-	args := make([]interface{}, 0, 5+len(a.Messages))
-	args = append(args,
-		"xclaim",
-		a.Stream,
-		a.Group, a.Consumer,
-		int64(a.MinIdle/time.Millisecond))
-	for _, id := range a.Messages {
-		args = append(args, id)
-	}
-	return args
-}
-
-// xTrim If approx is true, add the "~" parameter, otherwise it is the default "=" (redis default).
-// example:
-//
-//	XTRIM key MAXLEN/MINID threshold LIMIT limit.
-//	XTRIM key MAXLEN/MINID ~ threshold LIMIT limit.
-//
-// The redis-server version is lower than 6.2, please set limit to 0.
-func (c cmdable) xTrim(
-	ctx context.Context, key, strategy string,
-	approx bool, threshold interface{}, limit int64,
-) *IntCmd {
-	args := make([]interface{}, 0, 7)
-	args = append(args, "xtrim", key, strategy)
-	if approx {
-		args = append(args, "~")
-	}
-	args = append(args, threshold)
-	if limit > 0 {
-		args = append(args, "limit", limit)
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// XTrimMaxLen No `~` rules are used, `limit` cannot be used.
-// cmd: XTRIM key MAXLEN maxLen
-func (c cmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd {
-	return c.xTrim(ctx, key, "maxlen", false, maxLen, 0)
-}
-
-func (c cmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd {
-	return c.xTrim(ctx, key, "maxlen", true, maxLen, limit)
-}
-
-func (c cmdable) XTrimMinID(ctx context.Context, key string, minID string) *IntCmd {
-	return c.xTrim(ctx, key, "minid", false, minID, 0)
-}
-
-func (c cmdable) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd {
-	return c.xTrim(ctx, key, "minid", true, minID, limit)
-}
-
-func (c cmdable) XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd {
-	cmd := NewXInfoConsumersCmd(ctx, key, group)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd {
-	cmd := NewXInfoGroupsCmd(ctx, key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) XInfoStream(ctx context.Context, key string) *XInfoStreamCmd {
-	cmd := NewXInfoStreamCmd(ctx, key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// XInfoStreamFull XINFO STREAM FULL [COUNT count]
-// redis-server >= 6.0.
-func (c cmdable) XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd {
-	args := make([]interface{}, 0, 6)
-	args = append(args, "xinfo", "stream", key, "full")
-	if count > 0 {
-		args = append(args, "count", count)
-	}
-	cmd := NewXInfoStreamFullCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-// Z represents sorted set member.
-type Z struct {
-	Score  float64
-	Member interface{}
-}
-
-// ZWithKey represents sorted set member including the name of the key where it was popped.
-type ZWithKey struct {
-	Z
-	Key string
-}
-
-// ZStore is used as an arg to ZInter/ZInterStore and ZUnion/ZUnionStore.
-type ZStore struct {
-	Keys    []string
-	Weights []float64
-	// Can be SUM, MIN or MAX.
-	Aggregate string
-}
-
-func (z ZStore) len() (n int) {
-	n = len(z.Keys)
-	if len(z.Weights) > 0 {
-		n += 1 + len(z.Weights)
-	}
-	if z.Aggregate != "" {
-		n += 2
-	}
-	return n
-}
-
-func (z ZStore) appendArgs(args []interface{}) []interface{} {
-	for _, key := range z.Keys {
-		args = append(args, key)
-	}
-	if len(z.Weights) > 0 {
-		args = append(args, "weights")
-		for _, weights := range z.Weights {
-			args = append(args, weights)
-		}
-	}
-	if z.Aggregate != "" {
-		args = append(args, "aggregate", z.Aggregate)
-	}
-	return args
-}
-
-// BZPopMax Redis `BZPOPMAX key [key ...] timeout` command.
-func (c cmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
-	args := make([]interface{}, 1+len(keys)+1)
-	args[0] = "bzpopmax"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	args[len(args)-1] = formatSec(ctx, timeout)
-	cmd := NewZWithKeyCmd(ctx, args...)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// BZPopMin Redis `BZPOPMIN key [key ...] timeout` command.
-func (c cmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
-	args := make([]interface{}, 1+len(keys)+1)
-	args[0] = "bzpopmin"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	args[len(args)-1] = formatSec(ctx, timeout)
-	cmd := NewZWithKeyCmd(ctx, args...)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// BZMPop is the blocking variant of ZMPOP.
-// When any of the sorted sets contains elements, this command behaves exactly like ZMPOP.
-// When all sorted sets are empty, Redis will block the connection until another client adds members to one of the keys or until the timeout elapses.
-// A timeout of zero can be used to block indefinitely.
-// example: client.BZMPop(ctx, 0,"max", 1, "set")
-func (c cmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
-	args := make([]interface{}, 3+len(keys), 6+len(keys))
-	args[0] = "bzmpop"
-	args[1] = formatSec(ctx, timeout)
-	args[2] = len(keys)
-	for i, key := range keys {
-		args[3+i] = key
-	}
-	args = append(args, strings.ToLower(order), "count", count)
-	cmd := NewZSliceWithKeyCmd(ctx, args...)
-	cmd.setReadTimeout(timeout)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZAddArgs WARN: The GT, LT and NX options are mutually exclusive.
-type ZAddArgs struct {
-	NX      bool
-	XX      bool
-	LT      bool
-	GT      bool
-	Ch      bool
-	Members []Z
-}
-
-func (c cmdable) zAddArgs(key string, args ZAddArgs, incr bool) []interface{} {
-	a := make([]interface{}, 0, 6+2*len(args.Members))
-	a = append(a, "zadd", key)
-
-	// The GT, LT and NX options are mutually exclusive.
-	if args.NX {
-		a = append(a, "nx")
-	} else {
-		if args.XX {
-			a = append(a, "xx")
-		}
-		if args.GT {
-			a = append(a, "gt")
-		} else if args.LT {
-			a = append(a, "lt")
-		}
-	}
-	if args.Ch {
-		a = append(a, "ch")
-	}
-	if incr {
-		a = append(a, "incr")
-	}
-	for _, m := range args.Members {
-		a = append(a, m.Score)
-		a = append(a, m.Member)
-	}
-	return a
-}
-
-func (c cmdable) ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd {
-	cmd := NewIntCmd(ctx, c.zAddArgs(key, args, false)...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd {
-	cmd := NewFloatCmd(ctx, c.zAddArgs(key, args, true)...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZAdd Redis `ZADD key score member [score member ...]` command.
-func (c cmdable) ZAdd(ctx context.Context, key string, members ...Z) *IntCmd {
-	return c.ZAddArgs(ctx, key, ZAddArgs{
-		Members: members,
-	})
-}
-
-// ZAddLT Redis `ZADD key LT score member [score member ...]` command.
-func (c cmdable) ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd {
-	return c.ZAddArgs(ctx, key, ZAddArgs{
-		LT:      true,
-		Members: members,
-	})
-}
-
-// ZAddGT Redis `ZADD key GT score member [score member ...]` command.
-func (c cmdable) ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd {
-	return c.ZAddArgs(ctx, key, ZAddArgs{
-		GT:      true,
-		Members: members,
-	})
-}
-
-// ZAddNX Redis `ZADD key NX score member [score member ...]` command.
-func (c cmdable) ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd {
-	return c.ZAddArgs(ctx, key, ZAddArgs{
-		NX:      true,
-		Members: members,
-	})
-}
-
-// ZAddXX Redis `ZADD key XX score member [score member ...]` command.
-func (c cmdable) ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd {
-	return c.ZAddArgs(ctx, key, ZAddArgs{
-		XX:      true,
-		Members: members,
-	})
-}
-
-func (c cmdable) ZCard(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zcard", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZCount(ctx context.Context, key, min, max string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zcount", key, min, max)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZLexCount(ctx context.Context, key, min, max string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zlexcount", key, min, max)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd {
-	cmd := NewFloatCmd(ctx, "zincrby", key, increment, member)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd {
-	args := make([]interface{}, 0, 3+store.len())
-	args = append(args, "zinterstore", destination, len(store.Keys))
-	args = store.appendArgs(args)
-	cmd := NewIntCmd(ctx, args...)
-	cmd.SetFirstKeyPos(3)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZInter(ctx context.Context, store *ZStore) *StringSliceCmd {
-	args := make([]interface{}, 0, 2+store.len())
-	args = append(args, "zinter", len(store.Keys))
-	args = store.appendArgs(args)
-	cmd := NewStringSliceCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd {
-	args := make([]interface{}, 0, 3+store.len())
-	args = append(args, "zinter", len(store.Keys))
-	args = store.appendArgs(args)
-	args = append(args, "withscores")
-	cmd := NewZSliceCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd {
-	args := make([]interface{}, 4+len(keys))
-	args[0] = "zintercard"
-	numkeys := int64(0)
-	for i, key := range keys {
-		args[2+i] = key
-		numkeys++
-	}
-	args[1] = numkeys
-	args[2+numkeys] = "limit"
-	args[3+numkeys] = limit
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZMPop Pops one or more elements with the highest or lowest score from the first non-empty sorted set key from the list of provided key names.
-// direction: "max" (highest score) or "min" (lowest score), count: > 0
-// example: client.ZMPop(ctx, "max", 5, "set1", "set2")
-func (c cmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
-	args := make([]interface{}, 2+len(keys), 5+len(keys))
-	args[0] = "zmpop"
-	args[1] = len(keys)
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	args = append(args, strings.ToLower(order), "count", count)
-	cmd := NewZSliceWithKeyCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd {
-	args := make([]interface{}, 2+len(members))
-	args[0] = "zmscore"
-	args[1] = key
-	for i, member := range members {
-		args[2+i] = member
-	}
-	cmd := NewFloatSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd {
-	args := []interface{}{
-		"zpopmax",
-		key,
-	}
-
-	switch len(count) {
-	case 0:
-		break
-	case 1:
-		args = append(args, count[0])
-	default:
-		panic("too many arguments")
-	}
-
-	cmd := NewZSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd {
-	args := []interface{}{
-		"zpopmin",
-		key,
-	}
-
-	switch len(count) {
-	case 0:
-		break
-	case 1:
-		args = append(args, count[0])
-	default:
-		panic("too many arguments")
-	}
-
-	cmd := NewZSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZRangeArgs is all the options of the ZRange command.
-// In version> 6.2.0, you can replace the(cmd):
-//
-//	ZREVRANGE,
-//	ZRANGEBYSCORE,
-//	ZREVRANGEBYSCORE,
-//	ZRANGEBYLEX,
-//	ZREVRANGEBYLEX.
-//
-// Please pay attention to your redis-server version.
-//
-// Rev, ByScore, ByLex and Offset+Count options require redis-server 6.2.0 and higher.
-type ZRangeArgs struct {
-	Key string
-
-	// When the ByScore option is provided, the open interval(exclusive) can be set.
-	// By default, the score intervals specified by <Start> and <Stop> are closed (inclusive).
-	// It is similar to the deprecated(6.2.0+) ZRangeByScore command.
-	// For example:
-	//		ZRangeArgs{
-	//			Key: 				"example-key",
-	//	 		Start: 				"(3",
-	//	 		Stop: 				8,
-	//			ByScore:			true,
-	//	 	}
-	// 	 	cmd: "ZRange example-key (3 8 ByScore"  (3 < score <= 8).
-	//
-	// For the ByLex option, it is similar to the deprecated(6.2.0+) ZRangeByLex command.
-	// You can set the <Start> and <Stop> options as follows:
-	//		ZRangeArgs{
-	//			Key: 				"example-key",
-	//	 		Start: 				"[abc",
-	//	 		Stop: 				"(def",
-	//			ByLex:				true,
-	//	 	}
-	//		cmd: "ZRange example-key [abc (def ByLex"
-	//
-	// For normal cases (ByScore==false && ByLex==false), <Start> and <Stop> should be set to the index range (int).
-	// You can read the documentation for more information: https://redis.io/commands/zrange
-	Start interface{}
-	Stop  interface{}
-
-	// The ByScore and ByLex options are mutually exclusive.
-	ByScore bool
-	ByLex   bool
-
-	Rev bool
-
-	// limit offset count.
-	Offset int64
-	Count  int64
-}
-
-func (z ZRangeArgs) appendArgs(args []interface{}) []interface{} {
-	// For Rev+ByScore/ByLex, we need to adjust the position of <Start> and <Stop>.
-	if z.Rev && (z.ByScore || z.ByLex) {
-		args = append(args, z.Key, z.Stop, z.Start)
-	} else {
-		args = append(args, z.Key, z.Start, z.Stop)
-	}
-
-	if z.ByScore {
-		args = append(args, "byscore")
-	} else if z.ByLex {
-		args = append(args, "bylex")
-	}
-	if z.Rev {
-		args = append(args, "rev")
-	}
-	if z.Offset != 0 || z.Count != 0 {
-		args = append(args, "limit", z.Offset, z.Count)
-	}
-	return args
-}
-
-func (c cmdable) ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd {
-	args := make([]interface{}, 0, 9)
-	args = append(args, "zrange")
-	args = z.appendArgs(args)
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd {
-	args := make([]interface{}, 0, 10)
-	args = append(args, "zrange")
-	args = z.appendArgs(args)
-	args = append(args, "withscores")
-	cmd := NewZSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
-	return c.ZRangeArgs(ctx, ZRangeArgs{
-		Key:   key,
-		Start: start,
-		Stop:  stop,
-	})
-}
-
-func (c cmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
-	return c.ZRangeArgsWithScores(ctx, ZRangeArgs{
-		Key:   key,
-		Start: start,
-		Stop:  stop,
-	})
-}
-
-type ZRangeBy struct {
-	Min, Max      string
-	Offset, Count int64
-}
-
-func (c cmdable) zRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy, withScores bool) *StringSliceCmd {
-	args := []interface{}{zcmd, key, opt.Min, opt.Max}
-	if withScores {
-		args = append(args, "withscores")
-	}
-	if opt.Offset != 0 || opt.Count != 0 {
-		args = append(
-			args,
-			"limit",
-			opt.Offset,
-			opt.Count,
-		)
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
-	return c.zRangeBy(ctx, "zrangebyscore", key, opt, false)
-}
-
-func (c cmdable) ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
-	return c.zRangeBy(ctx, "zrangebylex", key, opt, false)
-}
-
-func (c cmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
-	args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"}
-	if opt.Offset != 0 || opt.Count != 0 {
-		args = append(
-			args,
-			"limit",
-			opt.Offset,
-			opt.Count,
-		)
-	}
-	cmd := NewZSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd {
-	args := make([]interface{}, 0, 10)
-	args = append(args, "zrangestore", dst)
-	args = z.appendArgs(args)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRank(ctx context.Context, key, member string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zrank", key, member)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZRankWithScore according to the Redis documentation, if member does not exist
-// in the sorted set or key does not exist, it will return a redis.Nil error.
-func (c cmdable) ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd {
-	cmd := NewRankWithScoreCmd(ctx, "zrank", key, member, "withscore")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(members))
-	args[0] = "zrem"
-	args[1] = key
-	args = appendArgs(args, members)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd {
-	cmd := NewIntCmd(
-		ctx,
-		"zremrangebyrank",
-		key,
-		start,
-		stop,
-	)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zremrangebyscore", key, min, max)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zremrangebylex", key, min, max)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "zrevrange", key, start, stop)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZRevRangeWithScores according to the Redis documentation, if member does not exist
-// in the sorted set or key does not exist, it will return a redis.Nil error.
-func (c cmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
-	cmd := NewZSliceCmd(ctx, "zrevrange", key, start, stop, "withscores")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) zRevRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy) *StringSliceCmd {
-	args := []interface{}{zcmd, key, opt.Max, opt.Min}
-	if opt.Offset != 0 || opt.Count != 0 {
-		args = append(
-			args,
-			"limit",
-			opt.Offset,
-			opt.Count,
-		)
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
-	return c.zRevRangeBy(ctx, "zrevrangebyscore", key, opt)
-}
-
-func (c cmdable) ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
-	return c.zRevRangeBy(ctx, "zrevrangebylex", key, opt)
-}
-
-func (c cmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
-	args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"}
-	if opt.Offset != 0 || opt.Count != 0 {
-		args = append(
-			args,
-			"limit",
-			opt.Offset,
-			opt.Count,
-		)
-	}
-	cmd := NewZSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRevRank(ctx context.Context, key, member string) *IntCmd {
-	cmd := NewIntCmd(ctx, "zrevrank", key, member)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd {
-	cmd := NewRankWithScoreCmd(ctx, "zrevrank", key, member, "withscore")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZScore(ctx context.Context, key, member string) *FloatCmd {
-	cmd := NewFloatCmd(ctx, "zscore", key, member)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZUnion(ctx context.Context, store ZStore) *StringSliceCmd {
-	args := make([]interface{}, 0, 2+store.len())
-	args = append(args, "zunion", len(store.Keys))
-	args = store.appendArgs(args)
-	cmd := NewStringSliceCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd {
-	args := make([]interface{}, 0, 3+store.len())
-	args = append(args, "zunion", len(store.Keys))
-	args = store.appendArgs(args)
-	args = append(args, "withscores")
-	cmd := NewZSliceCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd {
-	args := make([]interface{}, 0, 3+store.len())
-	args = append(args, "zunionstore", dest, len(store.Keys))
-	args = store.appendArgs(args)
-	cmd := NewIntCmd(ctx, args...)
-	cmd.SetFirstKeyPos(3)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZRandMember redis-server version >= 6.2.0.
-func (c cmdable) ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "zrandmember", key, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZRandMemberWithScores redis-server version >= 6.2.0.
-func (c cmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd {
-	cmd := NewZSliceCmd(ctx, "zrandmember", key, count, "withscores")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZDiff redis-server version >= 6.2.0.
-func (c cmdable) ZDiff(ctx context.Context, keys ...string) *StringSliceCmd {
-	args := make([]interface{}, 2+len(keys))
-	args[0] = "zdiff"
-	args[1] = len(keys)
-	for i, key := range keys {
-		args[i+2] = key
-	}
-
-	cmd := NewStringSliceCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZDiffWithScores redis-server version >= 6.2.0.
-func (c cmdable) ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd {
-	args := make([]interface{}, 3+len(keys))
-	args[0] = "zdiff"
-	args[1] = len(keys)
-	for i, key := range keys {
-		args[i+2] = key
-	}
-	args[len(keys)+2] = "withscores"
-
-	cmd := NewZSliceCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ZDiffStore redis-server version >=6.2.0.
-func (c cmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
-	args := make([]interface{}, 0, 3+len(keys))
-	args = append(args, "zdiffstore", destination, len(keys))
-	for _, key := range keys {
-		args = append(args, key)
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd {
-	args := make([]interface{}, 2, 2+len(els))
-	args[0] = "pfadd"
-	args[1] = key
-	args = appendArgs(args, els)
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PFCount(ctx context.Context, keys ...string) *IntCmd {
-	args := make([]interface{}, 1+len(keys))
-	args[0] = "pfcount"
-	for i, key := range keys {
-		args[1+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd {
-	args := make([]interface{}, 2+len(keys))
-	args[0] = "pfmerge"
-	args[1] = dest
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	cmd := NewStatusCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) BgRewriteAOF(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "bgrewriteaof")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) BgSave(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "bgsave")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientKill(ctx context.Context, ipPort string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "client", "kill", ipPort)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ClientKillByFilter is new style syntax, while the ClientKill is old
-//
-//	CLIENT KILL <option> [value] ... <option> [value]
-func (c cmdable) ClientKillByFilter(ctx context.Context, keys ...string) *IntCmd {
-	args := make([]interface{}, 2+len(keys))
-	args[0] = "client"
-	args[1] = "kill"
-	for i, key := range keys {
-		args[2+i] = key
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientList(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "client", "list")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientPause(ctx context.Context, dur time.Duration) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "client", "pause", formatMs(ctx, dur))
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientUnpause(ctx context.Context) *BoolCmd {
-	cmd := NewBoolCmd(ctx, "client", "unpause")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientID(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "client", "id")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientUnblock(ctx context.Context, id int64) *IntCmd {
-	cmd := NewIntCmd(ctx, "client", "unblock", id)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientUnblockWithError(ctx context.Context, id int64) *IntCmd {
-	cmd := NewIntCmd(ctx, "client", "unblock", id, "error")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClientInfo(ctx context.Context) *ClientInfoCmd {
-	cmd := NewClientInfoCmd(ctx, "client", "info")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ------------------------------------------------------------------------------------------------
-
-func (c cmdable) ConfigGet(ctx context.Context, parameter string) *MapStringStringCmd {
-	cmd := NewMapStringStringCmd(ctx, "config", "get", parameter)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ConfigResetStat(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "config", "resetstat")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ConfigSet(ctx context.Context, parameter, value string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "config", "set", parameter, value)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ConfigRewrite(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "config", "rewrite")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) DBSize(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "dbsize")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FlushAll(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "flushall")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FlushAllAsync(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "flushall", "async")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FlushDB(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "flushdb")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FlushDBAsync(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "flushdb", "async")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) Info(ctx context.Context, sections ...string) *StringCmd {
-	args := make([]interface{}, 1+len(sections))
-	args[0] = "info"
-	for i, section := range sections {
-		args[i+1] = section
-	}
-	cmd := NewStringCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) LastSave(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "lastsave")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) Save(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "save")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) shutdown(ctx context.Context, modifier string) *StatusCmd {
-	var args []interface{}
-	if modifier == "" {
-		args = []interface{}{"shutdown"}
-	} else {
-		args = []interface{}{"shutdown", modifier}
-	}
-	cmd := NewStatusCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	if err := cmd.Err(); err != nil {
-		if err == io.EOF {
-			// Server quit as expected.
-			cmd.err = nil
-		}
-	} else {
-		// Server did not quit. String reply contains the reason.
-		cmd.err = errors.New(cmd.val)
-		cmd.val = ""
-	}
-	return cmd
-}
-
-func (c cmdable) Shutdown(ctx context.Context) *StatusCmd {
-	return c.shutdown(ctx, "")
-}
-
-func (c cmdable) ShutdownSave(ctx context.Context) *StatusCmd {
-	return c.shutdown(ctx, "save")
-}
-
-func (c cmdable) ShutdownNoSave(ctx context.Context) *StatusCmd {
-	return c.shutdown(ctx, "nosave")
-}
-
-func (c cmdable) SlaveOf(ctx context.Context, host, port string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "slaveof", host, port)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SlowLogGet(ctx context.Context, num int64) *SlowLogCmd {
-	cmd := NewSlowLogCmd(context.Background(), "slowlog", "get", num)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) Sync(_ context.Context) {
-	panic("not implemented")
-}
-
-func (c cmdable) Time(ctx context.Context) *TimeCmd {
-	cmd := NewTimeCmd(ctx, "time")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) DebugObject(ctx context.Context, key string) *StringCmd {
-	cmd := NewStringCmd(ctx, "debug", "object", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ReadOnly(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "readonly")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ReadWrite(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "readwrite")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) MemoryUsage(ctx context.Context, key string, samples ...int) *IntCmd {
-	args := []interface{}{"memory", "usage", key}
-	if len(samples) > 0 {
-		if len(samples) != 1 {
-			panic("MemoryUsage expects single sample count")
-		}
-		args = append(args, "SAMPLES", samples[0])
-	}
-	cmd := NewIntCmd(ctx, args...)
-	cmd.SetFirstKeyPos(2)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
-	return c.eval(ctx, "eval", script, keys, args...)
-}
-
-func (c cmdable) EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
-	return c.eval(ctx, "eval_ro", script, keys, args...)
-}
-
-func (c cmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
-	return c.eval(ctx, "evalsha", sha1, keys, args...)
-}
-
-func (c cmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
-	return c.eval(ctx, "evalsha_ro", sha1, keys, args...)
-}
-
-func (c cmdable) eval(ctx context.Context, name, payload string, keys []string, args ...interface{}) *Cmd {
-	cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
-	cmdArgs[0] = name
-	cmdArgs[1] = payload
-	cmdArgs[2] = len(keys)
-	for i, key := range keys {
-		cmdArgs[3+i] = key
-	}
-	cmdArgs = appendArgs(cmdArgs, args)
-	cmd := NewCmd(ctx, cmdArgs...)
-
-	// it is possible that only args exist without a key.
-	// rdb.eval(ctx, eval, script, nil, arg1, arg2)
-	if len(keys) > 0 {
-		cmd.SetFirstKeyPos(3)
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
-	args := make([]interface{}, 2+len(hashes))
-	args[0] = "script"
-	args[1] = "exists"
-	for i, hash := range hashes {
-		args[2+i] = hash
-	}
-	cmd := NewBoolSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ScriptFlush(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "script", "flush")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ScriptKill(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "script", "kill")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ScriptLoad(ctx context.Context, script string) *StringCmd {
-	cmd := NewStringCmd(ctx, "script", "load", script)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ------------------------------------------------------------------------------
-
-// FunctionListQuery is used with FunctionList to query for Redis libraries
-//
-//	  	LibraryNamePattern 	- Use an empty string to get all libraries.
-//	  						- Use a glob-style pattern to match multiple libraries with a matching name
-//	  						- Use a library's full name to match a single library
-//		WithCode			- If true, it will return the code of the library
-type FunctionListQuery struct {
-	LibraryNamePattern string
-	WithCode           bool
-}
-
-func (c cmdable) FunctionLoad(ctx context.Context, code string) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "load", code)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionLoadReplace(ctx context.Context, code string) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "load", "replace", code)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionDelete(ctx context.Context, libName string) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "delete", libName)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionFlush(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "flush")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionKill(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "kill")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionFlushAsync(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "flush", "async")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionList(ctx context.Context, q FunctionListQuery) *FunctionListCmd {
-	args := make([]interface{}, 2, 5)
-	args[0] = "function"
-	args[1] = "list"
-	if q.LibraryNamePattern != "" {
-		args = append(args, "libraryname", q.LibraryNamePattern)
-	}
-	if q.WithCode {
-		args = append(args, "withcode")
-	}
-	cmd := NewFunctionListCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionDump(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "dump")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionRestore(ctx context.Context, libDump string) *StringCmd {
-	cmd := NewStringCmd(ctx, "function", "restore", libDump)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FunctionStats(ctx context.Context) *FunctionStatsCmd {
-	cmd := NewFunctionStatsCmd(ctx, "function", "stats")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) FCall(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
-	cmdArgs := fcallArgs("fcall", function, keys, args...)
-	cmd := NewCmd(ctx, cmdArgs...)
-	if len(keys) > 0 {
-		cmd.SetFirstKeyPos(3)
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// FCallRo this function simply calls FCallRO,
-// Deprecated: to maintain convention FCallRO.
-func (c cmdable) FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
-	return c.FCallRO(ctx, function, keys, args...)
-}
-
-func (c cmdable) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
-	cmdArgs := fcallArgs("fcall_ro", function, keys, args...)
-	cmd := NewCmd(ctx, cmdArgs...)
-	if len(keys) > 0 {
-		cmd.SetFirstKeyPos(3)
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func fcallArgs(command string, function string, keys []string, args ...interface{}) []interface{} {
-	cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
-	cmdArgs[0] = command
-	cmdArgs[1] = function
-	cmdArgs[2] = len(keys)
-	for i, key := range keys {
-		cmdArgs[3+i] = key
-	}
-
-	cmdArgs = append(cmdArgs, args...)
-	return cmdArgs
-}
-
-//------------------------------------------------------------------------------
-
-// Publish posts the message to the channel.
-func (c cmdable) Publish(ctx context.Context, channel string, message interface{}) *IntCmd {
-	cmd := NewIntCmd(ctx, "publish", channel, message)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) SPublish(ctx context.Context, channel string, message interface{}) *IntCmd {
-	cmd := NewIntCmd(ctx, "spublish", channel, message)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd {
-	args := []interface{}{"pubsub", "channels"}
-	if pattern != "*" {
-		args = append(args, pattern)
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PubSubNumSub(ctx context.Context, channels ...string) *MapStringIntCmd {
-	args := make([]interface{}, 2+len(channels))
-	args[0] = "pubsub"
-	args[1] = "numsub"
-	for i, channel := range channels {
-		args[2+i] = channel
-	}
-	cmd := NewMapStringIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PubSubShardChannels(ctx context.Context, pattern string) *StringSliceCmd {
-	args := []interface{}{"pubsub", "shardchannels"}
-	if pattern != "*" {
-		args = append(args, pattern)
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *MapStringIntCmd {
-	args := make([]interface{}, 2+len(channels))
-	args[0] = "pubsub"
-	args[1] = "shardnumsub"
-	for i, channel := range channels {
-		args[2+i] = channel
-	}
-	cmd := NewMapStringIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) PubSubNumPat(ctx context.Context) *IntCmd {
-	cmd := NewIntCmd(ctx, "pubsub", "numpat")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) ClusterMyShardID(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "cluster", "myshardid")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterSlots(ctx context.Context) *ClusterSlotsCmd {
-	cmd := NewClusterSlotsCmd(ctx, "cluster", "slots")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterShards(ctx context.Context) *ClusterShardsCmd {
-	cmd := NewClusterShardsCmd(ctx, "cluster", "shards")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterLinks(ctx context.Context) *ClusterLinksCmd {
-	cmd := NewClusterLinksCmd(ctx, "cluster", "links")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterNodes(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "cluster", "nodes")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterMeet(ctx context.Context, host, port string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "meet", host, port)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterForget(ctx context.Context, nodeID string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "forget", nodeID)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterReplicate(ctx context.Context, nodeID string) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "replicate", nodeID)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterResetSoft(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "reset", "soft")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterResetHard(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "reset", "hard")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterInfo(ctx context.Context) *StringCmd {
-	cmd := NewStringCmd(ctx, "cluster", "info")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterKeySlot(ctx context.Context, key string) *IntCmd {
-	cmd := NewIntCmd(ctx, "cluster", "keyslot", key)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "cluster", "getkeysinslot", slot, count)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterCountFailureReports(ctx context.Context, nodeID string) *IntCmd {
-	cmd := NewIntCmd(ctx, "cluster", "count-failure-reports", nodeID)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterCountKeysInSlot(ctx context.Context, slot int) *IntCmd {
-	cmd := NewIntCmd(ctx, "cluster", "countkeysinslot", slot)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterDelSlots(ctx context.Context, slots ...int) *StatusCmd {
-	args := make([]interface{}, 2+len(slots))
-	args[0] = "cluster"
-	args[1] = "delslots"
-	for i, slot := range slots {
-		args[2+i] = slot
-	}
-	cmd := NewStatusCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterDelSlotsRange(ctx context.Context, min, max int) *StatusCmd {
-	size := max - min + 1
-	slots := make([]int, size)
-	for i := 0; i < size; i++ {
-		slots[i] = min + i
-	}
-	return c.ClusterDelSlots(ctx, slots...)
-}
-
-func (c cmdable) ClusterSaveConfig(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "saveconfig")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterSlaves(ctx context.Context, nodeID string) *StringSliceCmd {
-	cmd := NewStringSliceCmd(ctx, "cluster", "slaves", nodeID)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterFailover(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "cluster", "failover")
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterAddSlots(ctx context.Context, slots ...int) *StatusCmd {
-	args := make([]interface{}, 2+len(slots))
-	args[0] = "cluster"
-	args[1] = "addslots"
-	for i, num := range slots {
-		args[2+i] = num
-	}
-	cmd := NewStatusCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ClusterAddSlotsRange(ctx context.Context, min, max int) *StatusCmd {
-	size := max - min + 1
-	slots := make([]int, size)
-	for i := 0; i < size; i++ {
-		slots[i] = min + i
-	}
-	return c.ClusterAddSlots(ctx, slots...)
-}
-
-//------------------------------------------------------------------------------
-
-func (c cmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd {
-	args := make([]interface{}, 2+3*len(geoLocation))
-	args[0] = "geoadd"
-	args[1] = key
-	for i, eachLoc := range geoLocation {
-		args[2+3*i] = eachLoc.Longitude
-		args[2+3*i+1] = eachLoc.Latitude
-		args[2+3*i+2] = eachLoc.Name
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// GeoRadius is a read-only GEORADIUS_RO command.
-func (c cmdable) GeoRadius(
-	ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,
-) *GeoLocationCmd {
-	cmd := NewGeoLocationCmd(ctx, query, "georadius_ro", key, longitude, latitude)
-	if query.Store != "" || query.StoreDist != "" {
-		cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))
-		return cmd
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// GeoRadiusStore is a writing GEORADIUS command.
-func (c cmdable) GeoRadiusStore(
-	ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,
-) *IntCmd {
-	args := geoLocationArgs(query, "georadius", key, longitude, latitude)
-	cmd := NewIntCmd(ctx, args...)
-	if query.Store == "" && query.StoreDist == "" {
-		cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
-		return cmd
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// GeoRadiusByMember is a read-only GEORADIUSBYMEMBER_RO command.
-func (c cmdable) GeoRadiusByMember(
-	ctx context.Context, key, member string, query *GeoRadiusQuery,
-) *GeoLocationCmd {
-	cmd := NewGeoLocationCmd(ctx, query, "georadiusbymember_ro", key, member)
-	if query.Store != "" || query.StoreDist != "" {
-		cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
-		return cmd
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.
-func (c cmdable) GeoRadiusByMemberStore(
-	ctx context.Context, key, member string, query *GeoRadiusQuery,
-) *IntCmd {
-	args := geoLocationArgs(query, "georadiusbymember", key, member)
-	cmd := NewIntCmd(ctx, args...)
-	if query.Store == "" && query.StoreDist == "" {
-		cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
-		return cmd
-	}
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd {
-	args := make([]interface{}, 0, 13)
-	args = append(args, "geosearch", key)
-	args = geoSearchArgs(q, args)
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) GeoSearchLocation(
-	ctx context.Context, key string, q *GeoSearchLocationQuery,
-) *GeoSearchLocationCmd {
-	args := make([]interface{}, 0, 16)
-	args = append(args, "geosearch", key)
-	args = geoSearchLocationArgs(q, args)
-	cmd := NewGeoSearchLocationCmd(ctx, q, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd {
-	args := make([]interface{}, 0, 15)
-	args = append(args, "geosearchstore", store, key)
-	args = geoSearchArgs(&q.GeoSearchQuery, args)
-	if q.StoreDist {
-		args = append(args, "storedist")
-	}
-	cmd := NewIntCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) GeoDist(
-	ctx context.Context, key string, member1, member2, unit string,
-) *FloatCmd {
-	if unit == "" {
-		unit = "km"
-	}
-	cmd := NewFloatCmd(ctx, "geodist", key, member1, member2, unit)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd {
-	args := make([]interface{}, 2+len(members))
-	args[0] = "geohash"
-	args[1] = key
-	for i, member := range members {
-		args[2+i] = member
-	}
-	cmd := NewStringSliceCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd {
-	args := make([]interface{}, 2+len(members))
-	args[0] = "geopos"
-	args[1] = key
-	for i, member := range members {
-		args[2+i] = member
-	}
-	cmd := NewGeoPosCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ACLDryRun(ctx context.Context, username string, command ...interface{}) *StringCmd {
-	args := make([]interface{}, 0, 3+len(command))
-	args = append(args, "acl", "dryrun", username)
-	args = append(args, command...)
-	cmd := NewStringCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-// ModuleLoadexConfig struct is used to specify the arguments for the MODULE LOADEX command of redis.
-// `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]`
-type ModuleLoadexConfig struct {
-	Path string
-	Conf map[string]interface{}
-	Args []interface{}
-}
-
-func (c *ModuleLoadexConfig) toArgs() []interface{} {
-	args := make([]interface{}, 3, 3+len(c.Conf)*3+len(c.Args)*2)
-	args[0] = "MODULE"
-	args[1] = "LOADEX"
-	args[2] = c.Path
-	for k, v := range c.Conf {
-		args = append(args, "CONFIG", k, v)
-	}
-	for _, arg := range c.Args {
-		args = append(args, "ARGS", arg)
-	}
-	return args
-}
-
-// ModuleLoadex Redis `MODULE LOADEX path [CONFIG name value [CONFIG name value ...]] [ARGS args [args ...]]` command.
-func (c cmdable) ModuleLoadex(ctx context.Context, conf *ModuleLoadexConfig) *StringCmd {
-	cmd := NewStringCmd(ctx, conf.toArgs()...)
-	_ = c(ctx, cmd)
-	return cmd
-}
-
-func (c cmdable) ACLLog(ctx context.Context, count int64) *ACLLogCmd {
-	args := make([]interface{}, 0, 3)
-	args = append(args, "acl", "log")
-	if count > 0 {
-		args = append(args, count)
-	}
-	cmd := NewACLLogCmd(ctx, args...)
-	_ = c(ctx, cmd)
-	return cmd
-}
+/*
+Monitor - represents a Redis MONITOR command, allowing the user to capture
+and process all commands sent to a Redis server. This mimics the behavior of
+MONITOR in the redis-cli.
 
-func (c cmdable) ACLLogReset(ctx context.Context) *StatusCmd {
-	cmd := NewStatusCmd(ctx, "acl", "log", "reset")
+Notes:
+- Using MONITOR blocks the connection to the server for itself. It needs a dedicated connection
+- The user should create a channel of type string
+- This runs concurrently in the background. Trigger via the Start and Stop functions
+See further: Redis MONITOR command: https://redis.io/commands/monitor
+*/
+func (c cmdable) Monitor(ctx context.Context, ch chan string) *MonitorCmd {
+	cmd := newMonitorCmd(ctx, ch)
 	_ = c(ctx, cmd)
 	return cmd
 }
diff --git a/commands_test.go b/commands_test.go
index f88cb21e8..d30a9d8bb 100644
--- a/commands_test.go
+++ b/commands_test.go
@@ -95,7 +95,19 @@ var _ = Describe("Commands", func() {
 			Expect(time.Now()).To(BeTemporally("~", start.Add(wait), 3*time.Second))
 		})
 
-		It("should Select", func() {
+		It("should WaitAOF", func() {
+			const waitAOF = 3 * time.Second
+			Skip("flaky test")
+
+			// assuming that the redis instance doesn't have AOF enabled
+			start := time.Now()
+			val, err := client.WaitAOF(ctx, 1, 1, waitAOF).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(val).NotTo(ContainSubstring("ERR WAITAOF cannot be used when numlocal is set but appendonly is disabled"))
+			Expect(time.Now()).To(BeTemporally("~", start.Add(waitAOF), 3*time.Second))
+		})
+
+		It("should Select", Label("NonRedisEnterprise"), func() {
 			pipe := client.Pipeline()
 			sel := pipe.Select(ctx, 1)
 			_, err := pipe.Exec(ctx)
@@ -105,7 +117,7 @@ var _ = Describe("Commands", func() {
 			Expect(sel.Val()).To(Equal("OK"))
 		})
 
-		It("should SwapDB", func() {
+		It("should SwapDB", Label("NonRedisEnterprise"), func() {
 			pipe := client.Pipeline()
 			sel := pipe.SwapDB(ctx, 1, 2)
 			_, err := pipe.Exec(ctx)
@@ -207,7 +219,7 @@ var _ = Describe("Commands", func() {
 			Expect(info).NotTo(BeNil())
 		})
 
-		It("should ClientPause", func() {
+		It("should ClientPause", Label("NonRedisEnterprise"), func() {
 			err := client.ClientPause(ctx, time.Second).Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -231,19 +243,80 @@ var _ = Describe("Commands", func() {
 			Expect(get.Val()).To(Equal("theclientname"))
 		})
 
+		It("should ClientSetInfo", func() {
+			pipe := client.Pipeline()
+
+			// Test setting the libName
+			libName := "go-redis"
+			libInfo := redis.WithLibraryName(libName)
+			setInfo := pipe.ClientSetInfo(ctx, libInfo)
+			_, err := pipe.Exec(ctx)
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(setInfo.Err()).NotTo(HaveOccurred())
+			Expect(setInfo.Val()).To(Equal("OK"))
+
+			// Test setting the libVer
+			libVer := "vX.x"
+			libInfo = redis.WithLibraryVersion(libVer)
+			setInfo = pipe.ClientSetInfo(ctx, libInfo)
+			_, err = pipe.Exec(ctx)
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(setInfo.Err()).NotTo(HaveOccurred())
+			Expect(setInfo.Val()).To(Equal("OK"))
+
+			// Test setting both fields, expect a panic
+			libInfo = redis.LibraryInfo{LibName: &libName, LibVer: &libVer}
+
+			Expect(func() {
+				defer func() {
+					if r := recover(); r != nil {
+						err := r.(error)
+						Expect(err).To(MatchError("both LibName and LibVer cannot be set at the same time"))
+					}
+				}()
+				pipe.ClientSetInfo(ctx, libInfo)
+			}).To(Panic())
+
+			// Test setting neither field, expect a panic
+			libInfo = redis.LibraryInfo{}
+
+			Expect(func() {
+				defer func() {
+					if r := recover(); r != nil {
+						err := r.(error)
+						Expect(err).To(MatchError("at least one of LibName and LibVer should be set"))
+					}
+				}()
+				pipe.ClientSetInfo(ctx, libInfo)
+			}).To(Panic())
+			// Test setting the default options for libName, libName suffix and libVer
+			clientInfo := client.ClientInfo(ctx).Val()
+			Expect(clientInfo.LibName).To(ContainSubstring("go-redis(go-redis,"))
+			// Test setting the libName suffix in options
+			opt := redisOptions()
+			opt.IdentitySuffix = "suffix"
+			client2 := redis.NewClient(opt)
+			defer client2.Close()
+			clientInfo = client2.ClientInfo(ctx).Val()
+			Expect(clientInfo.LibName).To(ContainSubstring("go-redis(suffix,"))
+
+		})
+
 		It("should ConfigGet", func() {
 			val, err := client.ConfigGet(ctx, "*").Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(val).NotTo(BeEmpty())
 		})
 
-		It("should ConfigResetStat", func() {
+		It("should ConfigResetStat", Label("NonRedisEnterprise"), func() {
 			r := client.ConfigResetStat(ctx)
 			Expect(r.Err()).NotTo(HaveOccurred())
 			Expect(r.Val()).To(Equal("OK"))
 		})
 
-		It("should ConfigSet", func() {
+		It("should ConfigSet", Label("NonRedisEnterprise"), func() {
 			configGet := client.ConfigGet(ctx, "maxmemory")
 			Expect(configGet.Err()).NotTo(HaveOccurred())
 			Expect(configGet.Val()).To(HaveLen(1))
@@ -255,7 +328,7 @@ var _ = Describe("Commands", func() {
 			Expect(configSet.Val()).To(Equal("OK"))
 		})
 
-		It("should ConfigRewrite", func() {
+		It("should ConfigRewrite", Label("NonRedisEnterprise"), func() {
 			configRewrite := client.ConfigRewrite(ctx)
 			Expect(configRewrite.Err()).NotTo(HaveOccurred())
 			Expect(configRewrite.Val()).To(Equal("OK"))
@@ -273,6 +346,20 @@ var _ = Describe("Commands", func() {
 			Expect(info.Val()).NotTo(Equal(""))
 		})
 
+		It("should InfoMap", Label("redis.info"), func() {
+			info := client.InfoMap(ctx)
+			Expect(info.Err()).NotTo(HaveOccurred())
+			Expect(info.Val()).NotTo(BeNil())
+
+			info = client.InfoMap(ctx, "dummy")
+			Expect(info.Err()).NotTo(HaveOccurred())
+			Expect(info.Val()).To(BeNil())
+
+			info = client.InfoMap(ctx, "server")
+			Expect(info.Err()).NotTo(HaveOccurred())
+			Expect(info.Val()).To(HaveLen(1))
+		})
+
 		It("should Info cpu", func() {
 			info := client.Info(ctx, "cpu")
 			Expect(info.Err()).NotTo(HaveOccurred())
@@ -288,20 +375,20 @@ var _ = Describe("Commands", func() {
 			Expect(info.Val()).To(ContainSubstring(`memory`))
 		})
 
-		It("should LastSave", func() {
+		It("should LastSave", Label("NonRedisEnterprise"), func() {
 			lastSave := client.LastSave(ctx)
 			Expect(lastSave.Err()).NotTo(HaveOccurred())
 			Expect(lastSave.Val()).NotTo(Equal(0))
 		})
 
-		It("should Save", func() {
+		It("should Save", Label("NonRedisEnterprise"), func() {
 			// workaround for "ERR Background save already in progress"
 			Eventually(func() string {
 				return client.Save(ctx).Val()
 			}, "10s").Should(Equal("OK"))
 		})
 
-		It("should SlaveOf", func() {
+		It("should SlaveOf", Label("NonRedisEnterprise"), func() {
 			slaveOf := client.SlaveOf(ctx, "localhost", "8888")
 			Expect(slaveOf.Err()).NotTo(HaveOccurred())
 			Expect(slaveOf.Val()).To(Equal("OK"))
@@ -317,7 +404,7 @@ var _ = Describe("Commands", func() {
 			Expect(tm).To(BeTemporally("~", time.Now(), 3*time.Second))
 		})
 
-		It("should Command", func() {
+		It("should Command", Label("NonRedisEnterprise"), func() {
 			cmds, err := client.Command(ctx).Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(len(cmds)).To(BeNumerically("~", 240, 25))
@@ -362,7 +449,6 @@ var _ = Describe("Commands", func() {
 		})
 
 		It("should filter commands by ACL category", func() {
-
 			filter := &redis.FilterBy{
 				ACLCat: "admin",
 			}
@@ -529,7 +615,6 @@ var _ = Describe("Commands", func() {
 			n, err = client.Exists(ctx, "key").Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(n).To(Equal(int64(0)))
-
 		})
 
 		It("should Keys", func() {
@@ -550,7 +635,7 @@ var _ = Describe("Commands", func() {
 			Expect(keys.Val()).To(ConsistOf([]string{"four", "one", "three", "two"}))
 		})
 
-		It("should Migrate", func() {
+		It("should Migrate", Label("NonRedisEnterprise"), func() {
 			migrate := client.Migrate(ctx, "localhost", redisSecondaryPort, "key", 0, 0)
 			Expect(migrate.Err()).NotTo(HaveOccurred())
 			Expect(migrate.Val()).To(Equal("NOKEY"))
@@ -564,7 +649,7 @@ var _ = Describe("Commands", func() {
 			Expect(migrate.Val()).To(Equal(""))
 		})
 
-		It("should Move", func() {
+		It("should Move", Label("NonRedisEnterprise"), func() {
 			move := client.Move(ctx, "key", 2)
 			Expect(move.Err()).NotTo(HaveOccurred())
 			Expect(move.Val()).To(Equal(false))
@@ -591,7 +676,7 @@ var _ = Describe("Commands", func() {
 			Expect(get.Val()).To(Equal("hello"))
 		})
 
-		It("should Object", func() {
+		It("should Object", Label("NonRedisEnterprise"), func() {
 			start := time.Now()
 			set := client.Set(ctx, "key", "hello", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
@@ -601,6 +686,11 @@ var _ = Describe("Commands", func() {
 			Expect(refCount.Err()).NotTo(HaveOccurred())
 			Expect(refCount.Val()).To(Equal(int64(1)))
 
+			client.ConfigSet(ctx, "maxmemory-policy", "volatile-lfu")
+			freq := client.ObjectFreq(ctx, "key")
+			Expect(freq.Err()).NotTo(HaveOccurred())
+			client.ConfigSet(ctx, "maxmemory-policy", "noeviction") // default
+
 			err := client.ObjectEncoding(ctx, "key").Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -676,7 +766,6 @@ var _ = Describe("Commands", func() {
 		})
 
 		It("should PExpireTime", func() {
-
 			// The command returns -1 if the key exists but has no associated expiration time.
 			// The command returns -2 if the key does not exist.
 			pExpireTime := client.PExpireTime(ctx, "key")
@@ -726,7 +815,7 @@ var _ = Describe("Commands", func() {
 			Expect(randomKey.Val()).To(Equal("key"))
 		})
 
-		It("should Rename", func() {
+		It("should Rename", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key", "hello", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -740,7 +829,7 @@ var _ = Describe("Commands", func() {
 			Expect(get.Val()).To(Equal("hello"))
 		})
 
-		It("should RenameNX", func() {
+		It("should RenameNX", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key", "hello", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -841,7 +930,7 @@ var _ = Describe("Commands", func() {
 			Expect(els).To(Equal([]string{"1", "2"}))
 		})
 
-		It("should Sort and Get", func() {
+		It("should Sort and Get", Label("NonRedisEnterprise"), func() {
 			size, err := client.LPush(ctx, "list", "1").Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(size).To(Equal(int64(1)))
@@ -874,7 +963,7 @@ var _ = Describe("Commands", func() {
 			}
 		})
 
-		It("should Sort and Store", func() {
+		It("should Sort and Store", Label("NonRedisEnterprise"), func() {
 			size, err := client.LPush(ctx, "list", "1").Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(size).To(Equal(int64(1)))
@@ -915,7 +1004,6 @@ var _ = Describe("Commands", func() {
 		})
 
 		It("should ExpireTime", func() {
-
 			// The command returns -1 if the key exists but has no associated expiration time.
 			// The command returns -2 if the key does not exist.
 			expireTimeCmd := client.ExpireTime(ctx, "key")
@@ -937,7 +1025,6 @@ var _ = Describe("Commands", func() {
 		})
 
 		It("should TTL", func() {
-
 			// The command returns -1 if the key exists but has no associated expire
 			// The command returns -2 if the key does not exist.
 			ttl := client.TTL(ctx, "key")
@@ -1076,7 +1163,7 @@ var _ = Describe("Commands", func() {
 			Expect(bitCount.Val()).To(Equal(int64(6)))
 		})
 
-		It("should BitOpAnd", func() {
+		It("should BitOpAnd", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key1", "1", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -1094,7 +1181,7 @@ var _ = Describe("Commands", func() {
 			Expect(get.Val()).To(Equal("0"))
 		})
 
-		It("should BitOpOr", func() {
+		It("should BitOpOr", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key1", "1", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -1112,7 +1199,7 @@ var _ = Describe("Commands", func() {
 			Expect(get.Val()).To(Equal("1"))
 		})
 
-		It("should BitOpXor", func() {
+		It("should BitOpXor", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key1", "\xff", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -1130,7 +1217,7 @@ var _ = Describe("Commands", func() {
 			Expect(get.Val()).To(Equal("\xf0"))
 		})
 
-		It("should BitOpNot", func() {
+		It("should BitOpNot", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key1", "\x00", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -1202,6 +1289,24 @@ var _ = Describe("Commands", func() {
 			nn, err := client.BitField(ctx, "mykey", "INCRBY", "i5", 100, 1, "GET", "u4", 0).Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(nn).To(Equal([]int64{1, 0}))
+
+			nn, err = client.BitField(ctx, "mykey", "set", "i1", 1, 1, "GET", "u4", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(nn).To(Equal([]int64{0, 4}))
+		})
+
+		It("should BitFieldRO", func() {
+			nn, err := client.BitField(ctx, "mykey", "SET", "u8", 8, 255).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(nn).To(Equal([]int64{0}))
+
+			nn, err = client.BitFieldRO(ctx, "mykey", "u8", 0).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(nn).To(Equal([]int64{0}))
+
+			nn, err = client.BitFieldRO(ctx, "mykey", "u8", 0, "u4", 8, "u4", 12, "u4", 13).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(nn).To(Equal([]int64{0, 15, 15, 14}))
 		})
 
 		It("should Decr", func() {
@@ -1441,7 +1546,7 @@ var _ = Describe("Commands", func() {
 			}))
 		})
 
-		It("should MSetNX", func() {
+		It("should MSetNX", Label("NonRedisEnterprise"), func() {
 			mSetNX := client.MSetNX(ctx, "key1", "hello1", "key2", "hello2")
 			Expect(mSetNX.Err()).NotTo(HaveOccurred())
 			Expect(mSetNX.Val()).To(Equal(true))
@@ -1906,7 +2011,7 @@ var _ = Describe("Commands", func() {
 			Expect(strLen.Val()).To(Equal(int64(0)))
 		})
 
-		It("should Copy", func() {
+		It("should Copy", Label("NonRedisEnterprise"), func() {
 			set := client.Set(ctx, "key", "hello", 0)
 			Expect(set.Err()).NotTo(HaveOccurred())
 			Expect(set.Val()).To(Equal("OK"))
@@ -1938,7 +2043,7 @@ var _ = Describe("Commands", func() {
 			Expect(dryRun.Val()).To(Equal("OK"))
 		})
 
-		It("should fail module loadex", func() {
+		It("should fail module loadex", Label("NonRedisEnterprise"), func() {
 			dryRun := client.ModuleLoadex(ctx, &redis.ModuleLoadexConfig{
 				Path: "/path/to/non-existent-library.so",
 				Conf: map[string]interface{}{
@@ -1986,8 +2091,7 @@ var _ = Describe("Commands", func() {
 			Expect(args).To(Equal(expectedArgs))
 		})
 
-		It("should ACL LOG", func() {
-
+		It("should ACL LOG", Label("NonRedisEnterprise"), func() {
 			err := client.Do(ctx, "acl", "setuser", "test", ">test", "on", "allkeys", "+get").Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -2001,10 +2105,9 @@ var _ = Describe("Commands", func() {
 
 			logEntries, err := client.ACLLog(ctx, 10).Result()
 			Expect(err).NotTo(HaveOccurred())
-			Expect(len(logEntries)).To(Equal(3))
+			Expect(len(logEntries)).To(Equal(4))
 
 			for _, entry := range logEntries {
-				Expect(entry.Count).To(BeNumerically("==", 1))
 				Expect(entry.Reason).To(Equal("command"))
 				Expect(entry.Context).To(Equal("toplevel"))
 				Expect(entry.Object).NotTo(BeEmpty())
@@ -2019,10 +2122,9 @@ var _ = Describe("Commands", func() {
 			limitedLogEntries, err := client.ACLLog(ctx, 2).Result()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(len(limitedLogEntries)).To(Equal(2))
-
 		})
 
-		It("should ACL LOG RESET", func() {
+		It("should ACL LOG RESET", Label("NonRedisEnterprise"), func() {
 			// Call ACL LOG RESET
 			resetCmd := client.ACLLogReset(ctx)
 			Expect(resetCmd.Err()).NotTo(HaveOccurred())
@@ -2033,7 +2135,6 @@ var _ = Describe("Commands", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(len(logEntries)).To(Equal(0))
 		})
-
 	})
 
 	Describe("hashes", func() {
@@ -2332,7 +2433,7 @@ var _ = Describe("Commands", func() {
 	})
 
 	Describe("hyperloglog", func() {
-		It("should PFMerge", func() {
+		It("should PFMerge", Label("NonRedisEnterprise"), func() {
 			pfAdd := client.PFAdd(ctx, "hll1", "1", "2", "3", "4", "5")
 			Expect(pfAdd.Err()).NotTo(HaveOccurred())
 
@@ -2357,7 +2458,7 @@ var _ = Describe("Commands", func() {
 	})
 
 	Describe("lists", func() {
-		It("should BLPop", func() {
+		It("should BLPop", Label("NonRedisEnterprise"), func() {
 			rPush := client.RPush(ctx, "list1", "a", "b", "c")
 			Expect(rPush.Err()).NotTo(HaveOccurred())
 
@@ -2411,7 +2512,7 @@ var _ = Describe("Commands", func() {
 			Expect(stats.Timeouts).To(Equal(uint32(0)))
 		})
 
-		It("should BRPop", func() {
+		It("should BRPop", Label("NonRedisEnterprise"), func() {
 			rPush := client.RPush(ctx, "list1", "a", "b", "c")
 			Expect(rPush.Err()).NotTo(HaveOccurred())
 
@@ -2453,7 +2554,7 @@ var _ = Describe("Commands", func() {
 			}
 		})
 
-		It("should BRPopLPush", func() {
+		It("should BRPopLPush", Label("NonRedisEnterprise"), func() {
 			_, err := client.BRPopLPush(ctx, "list1", "list2", time.Second).Result()
 			Expect(err).To(Equal(redis.Nil))
 
@@ -2465,7 +2566,7 @@ var _ = Describe("Commands", func() {
 			Expect(v).To(Equal("c"))
 		})
 
-		It("should LCS", func() {
+		It("should LCS", Label("NonRedisEnterprise"), func() {
 			err := client.MSet(ctx, "key1", "ohmytext", "key2", "mynewtext").Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -2579,7 +2680,7 @@ var _ = Describe("Commands", func() {
 			Expect(lRange.Val()).To(Equal([]string{"Hello", "There", "World"}))
 		})
 
-		It("should LMPop", func() {
+		It("should LMPop", Label("NonRedisEnterprise"), func() {
 			err := client.LPush(ctx, "list1", "one", "two", "three", "four", "five").Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -2619,7 +2720,7 @@ var _ = Describe("Commands", func() {
 			Expect(err).To(HaveOccurred())
 		})
 
-		It("should BLMPop", func() {
+		It("should BLMPop", Label("NonRedisEnterprise"), func() {
 			err := client.LPush(ctx, "list1", "one", "two", "three", "four", "five").Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -2645,7 +2746,6 @@ var _ = Describe("Commands", func() {
 			Expect(err).NotTo(HaveOccurred())
 			Expect(key).To(Equal("list2"))
 			Expect(val).To(Equal([]string{"a", "b", "c", "d"}))
-
 		})
 
 		It("should BLMPopBlocks", func() {
@@ -2667,7 +2767,7 @@ var _ = Describe("Commands", func() {
 			case <-done:
 				Fail("BLMPop is not blocked")
 			case <-time.After(time.Second):
-				//ok
+				// ok
 			}
 
 			_, err := client.LPush(ctx, "list_list", "a").Result()
@@ -2675,7 +2775,7 @@ var _ = Describe("Commands", func() {
 
 			select {
 			case <-done:
-				//ok
+				// ok
 			case <-time.After(time.Second):
 				Fail("BLMPop is still blocked")
 			}
@@ -2954,7 +3054,7 @@ var _ = Describe("Commands", func() {
 			Expect(lRange.Val()).To(Equal([]string{"one", "two"}))
 		})
 
-		It("should RPopLPush", func() {
+		It("should RPopLPush", Label("NonRedisEnterprise"), func() {
 			rPush := client.RPush(ctx, "list", "one")
 			Expect(rPush.Err()).NotTo(HaveOccurred())
 			rPush = client.RPush(ctx, "list", "two")
@@ -3023,7 +3123,7 @@ var _ = Describe("Commands", func() {
 			Expect(lRange.Val()).To(Equal([]string{}))
 		})
 
-		It("should LMove", func() {
+		It("should LMove", Label("NonRedisEnterprise"), func() {
 			rPush := client.RPush(ctx, "lmove1", "ichi")
 			Expect(rPush.Err()).NotTo(HaveOccurred())
 			Expect(rPush.Val()).To(Equal(int64(1)))
@@ -3045,7 +3145,7 @@ var _ = Describe("Commands", func() {
 			Expect(lRange.Val()).To(Equal([]string{"san"}))
 		})
 
-		It("should BLMove", func() {
+		It("should BLMove", Label("NonRedisEnterprise"), func() {
 			rPush := client.RPush(ctx, "blmove1", "ichi")
 			Expect(rPush.Err()).NotTo(HaveOccurred())
 			Expect(rPush.Val()).To(Equal(int64(1)))
@@ -3112,7 +3212,7 @@ var _ = Describe("Commands", func() {
 			Expect(sCard.Val()).To(Equal(int64(2)))
 		})
 
-		It("should SDiff", func() {
+		It("should SDiff", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3132,7 +3232,7 @@ var _ = Describe("Commands", func() {
 			Expect(sDiff.Val()).To(ConsistOf([]string{"a", "b"}))
 		})
 
-		It("should SDiffStore", func() {
+		It("should SDiffStore", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3156,7 +3256,7 @@ var _ = Describe("Commands", func() {
 			Expect(sMembers.Val()).To(ConsistOf([]string{"a", "b"}))
 		})
 
-		It("should SInter", func() {
+		It("should SInter", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3176,7 +3276,7 @@ var _ = Describe("Commands", func() {
 			Expect(sInter.Val()).To(Equal([]string{"c"}))
 		})
 
-		It("should SInterCard", func() {
+		It("should SInterCard", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3206,7 +3306,7 @@ var _ = Describe("Commands", func() {
 			Expect(sInterCard.Val()).To(Equal(int64(2)))
 		})
 
-		It("should SInterStore", func() {
+		It("should SInterStore", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3274,7 +3374,7 @@ var _ = Describe("Commands", func() {
 			Expect(sMembersMap.Val()).To(Equal(map[string]struct{}{"Hello": {}, "World": {}}))
 		})
 
-		It("should SMove", func() {
+		It("should SMove", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "one")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "two")
@@ -3382,7 +3482,7 @@ var _ = Describe("Commands", func() {
 			Expect(sMembers.Val()).To(ConsistOf([]string{"three", "two"}))
 		})
 
-		It("should SUnion", func() {
+		It("should SUnion", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3402,7 +3502,7 @@ var _ = Describe("Commands", func() {
 			Expect(sUnion.Val()).To(HaveLen(5))
 		})
 
-		It("should SUnionStore", func() {
+		It("should SUnionStore", Label("NonRedisEnterprise"), func() {
 			sAdd := client.SAdd(ctx, "set1", "a")
 			Expect(sAdd.Err()).NotTo(HaveOccurred())
 			sAdd = client.SAdd(ctx, "set1", "b")
@@ -3428,7 +3528,7 @@ var _ = Describe("Commands", func() {
 	})
 
 	Describe("sorted sets", func() {
-		It("should BZPopMax", func() {
+		It("should BZPopMax", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{
 				Score:  1,
 				Member: "one",
@@ -3510,7 +3610,7 @@ var _ = Describe("Commands", func() {
 			Expect(stats.Timeouts).To(Equal(uint32(0)))
 		})
 
-		It("should BZPopMin", func() {
+		It("should BZPopMin", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{
 				Score:  1,
 				Member: "one",
@@ -4092,7 +4192,7 @@ var _ = Describe("Commands", func() {
 			}}))
 		})
 
-		It("should ZInterStore", func() {
+		It("should ZInterStore", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{
 				Score:  1,
 				Member: "one",
@@ -4129,8 +4229,7 @@ var _ = Describe("Commands", func() {
 			}}))
 		})
 
-		It("should ZMPop", func() {
-
+		It("should ZMPop", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err()
@@ -4202,11 +4301,9 @@ var _ = Describe("Commands", func() {
 				Score:  6,
 				Member: "six",
 			}}))
-
 		})
 
-		It("should BZMPop", func() {
-
+		It("should BZMPop", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset", redis.Z{Score: 2, Member: "two"}).Err()
@@ -4306,7 +4403,7 @@ var _ = Describe("Commands", func() {
 			case <-done:
 				Fail("BZMPop is not blocked")
 			case <-time.After(time.Second):
-				//ok
+				// ok
 			}
 
 			err := client.ZAdd(ctx, "list_list", redis.Z{Score: 1, Member: "one"}).Err()
@@ -4314,7 +4411,7 @@ var _ = Describe("Commands", func() {
 
 			select {
 			case <-done:
-				//ok
+				// ok
 			case <-time.After(time.Second):
 				Fail("BZMPop is still blocked")
 			}
@@ -4746,7 +4843,7 @@ var _ = Describe("Commands", func() {
 			Expect(vals).To(Equal([]redis.Z{}))
 		})
 
-		It("should ZRangeStore", func() {
+		It("should ZRangeStore", Label("NonRedisEnterprise"), func() {
 			added, err := client.ZAddArgs(ctx, "zset", redis.ZAddArgs{
 				Members: []redis.Z{
 					{Score: 1, Member: "one"},
@@ -5122,7 +5219,7 @@ var _ = Describe("Commands", func() {
 			Expect(zScore.Val()).To(Equal(1.001))
 		})
 
-		It("should ZUnion", func() {
+		It("should ZUnion", Label("NonRedisEnterprise"), func() {
 			err := client.ZAddArgs(ctx, "zset1", redis.ZAddArgs{
 				Members: []redis.Z{
 					{Score: 1, Member: "one"},
@@ -5161,7 +5258,7 @@ var _ = Describe("Commands", func() {
 			}))
 		})
 
-		It("should ZUnionStore", func() {
+		It("should ZUnionStore", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -5217,7 +5314,7 @@ var _ = Describe("Commands", func() {
 			))
 		})
 
-		It("should ZDiff", func() {
+		It("should ZDiff", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -5232,7 +5329,7 @@ var _ = Describe("Commands", func() {
 			Expect(v).To(Equal([]string{"two", "three"}))
 		})
 
-		It("should ZDiffWithScores", func() {
+		It("should ZDiffWithScores", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -5256,7 +5353,7 @@ var _ = Describe("Commands", func() {
 			}))
 		})
 
-		It("should ZInter", func() {
+		It("should ZInter", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -5275,7 +5372,7 @@ var _ = Describe("Commands", func() {
 			Expect(v).To(Equal([]string{"one", "two"}))
 		})
 
-		It("should ZInterCard", func() {
+		It("should ZInterCard", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -5301,7 +5398,7 @@ var _ = Describe("Commands", func() {
 			Expect(sInterCard.Val()).To(Equal(int64(2)))
 		})
 
-		It("should ZInterWithScores", func() {
+		It("should ZInterWithScores", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -5331,7 +5428,7 @@ var _ = Describe("Commands", func() {
 			}))
 		})
 
-		It("should ZDiffStore", func() {
+		It("should ZDiffStore", Label("NonRedisEnterprise"), func() {
 			err := client.ZAdd(ctx, "zset1", redis.Z{Score: 1, Member: "one"}).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.ZAdd(ctx, "zset1", redis.Z{Score: 2, Member: "two"}).Err()
@@ -6062,7 +6159,7 @@ var _ = Describe("Commands", func() {
 			Expect(res[1].Name).To(Equal("Catania"))
 		})
 
-		It("should geo radius and store the result", func() {
+		It("should geo radius and store the result", Label("NonRedisEnterprise"), func() {
 			n, err := client.GeoRadiusStore(ctx, "Sicily", 15, 37, &redis.GeoRadiusQuery{
 				Radius: 200,
 				Store:  "result",
@@ -6082,7 +6179,7 @@ var _ = Describe("Commands", func() {
 			}))
 		})
 
-		It("should geo radius and store dist", func() {
+		It("should geo radius and store dist", Label("NonRedisEnterprise"), func() {
 			n, err := client.GeoRadiusStore(ctx, "Sicily", 15, 37, &redis.GeoRadiusQuery{
 				Radius:    200,
 				StoreDist: "result",
@@ -6364,7 +6461,7 @@ var _ = Describe("Commands", func() {
 			}))
 		})
 
-		It("should geo search store", func() {
+		It("should geo search store", Label("NonRedisEnterprise"), func() {
 			q := &redis.GeoSearchStoreQuery{
 				GeoSearchQuery: redis.GeoSearchQuery{
 					Longitude:  15,
@@ -6624,7 +6721,7 @@ var _ = Describe("Commands", func() {
 			q = redis.FunctionListQuery{}
 		})
 
-		It("Loads a new library", func() {
+		It("Loads a new library", Label("NonRedisEnterprise"), func() {
 			functionLoad := client.FunctionLoad(ctx, lib1Code)
 			Expect(functionLoad.Err()).NotTo(HaveOccurred())
 			Expect(functionLoad.Val()).To(Equal(lib1.Name))
@@ -6634,7 +6731,7 @@ var _ = Describe("Commands", func() {
 			Expect(functionList.Val()).To(HaveLen(1))
 		})
 
-		It("Loads and replaces a new library", func() {
+		It("Loads and replaces a new library", Label("NonRedisEnterprise"), func() {
 			// Load a library for the first time
 			err := client.FunctionLoad(ctx, lib1Code).Err()
 			Expect(err).NotTo(HaveOccurred())
@@ -6705,7 +6802,7 @@ var _ = Describe("Commands", func() {
 			// Add test for a long-running function, once we make the test for `function stats` pass
 		})
 
-		It("Lists registered functions", func() {
+		It("Lists registered functions", Label("NonRedisEnterprise"), func() {
 			err := client.FunctionLoad(ctx, lib1Code).Err()
 			Expect(err).NotTo(HaveOccurred())
 
@@ -6744,7 +6841,7 @@ var _ = Describe("Commands", func() {
 			Expect(err).To(Equal(redis.Nil))
 		})
 
-		It("Dump and restores all libraries", func() {
+		It("Dump and restores all libraries", Label("NonRedisEnterprise"), func() {
 			err := client.FunctionLoad(ctx, lib1Code).Err()
 			Expect(err).NotTo(HaveOccurred())
 			err = client.FunctionLoad(ctx, lib2Code).Err()
@@ -6874,7 +6971,6 @@ var _ = Describe("Commands", func() {
 
 			close(started)
 		})
-
 	})
 
 	Describe("SlowLogGet", func() {
@@ -6895,7 +6991,6 @@ var _ = Describe("Commands", func() {
 			Expect(len(result)).NotTo(BeZero())
 		})
 	})
-
 })
 
 type numberStruct struct {
diff --git a/doctests/lpush_lrange_test.go b/doctests/lpush_lrange_test.go
index 64020c915..1e69f4b0a 100644
--- a/doctests/lpush_lrange_test.go
+++ b/doctests/lpush_lrange_test.go
@@ -5,10 +5,11 @@ package example_commands_test
 import (
 	"context"
 	"fmt"
+
 	"github.com/redis/go-redis/v9"
 )
 
-func ExampleLPushLRange() {
+func ExampleClient_LPush_and_lrange() {
 	ctx := context.Background()
 
 	rdb := redis.NewClient(&redis.Options{
diff --git a/doctests/set_get_test.go b/doctests/set_get_test.go
index 792bd4190..ab3a93603 100644
--- a/doctests/set_get_test.go
+++ b/doctests/set_get_test.go
@@ -5,10 +5,11 @@ package example_commands_test
 import (
 	"context"
 	"fmt"
+
 	"github.com/redis/go-redis/v9"
 )
 
-func ExampleSetGet() {
+func ExampleClient_Set_and_get() {
 	ctx := context.Background()
 
 	rdb := redis.NewClient(&redis.Options{
diff --git a/error.go b/error.go
index d5ebad60f..9b348193a 100644
--- a/error.go
+++ b/error.go
@@ -2,10 +2,12 @@ package redis
 
 import (
 	"context"
+	"errors"
 	"io"
 	"net"
 	"strings"
 
+	"github.com/redis/go-redis/v9/internal"
 	"github.com/redis/go-redis/v9/internal/pool"
 	"github.com/redis/go-redis/v9/internal/proto"
 )
@@ -15,11 +17,11 @@ var ErrClosed = pool.ErrClosed
 
 // HasErrorPrefix checks if the err is a Redis error and the message contains a prefix.
 func HasErrorPrefix(err error, prefix string) bool {
-	err, ok := err.(Error)
-	if !ok {
+	var rErr Error
+	if !errors.As(err, &rErr) {
 		return false
 	}
-	msg := err.Error()
+	msg := rErr.Error()
 	msg = strings.TrimPrefix(msg, "ERR ") // KVRocks adds such prefix
 	return strings.HasPrefix(msg, prefix)
 }
@@ -128,7 +130,9 @@ func isMovedError(err error) (moved bool, ask bool, addr string) {
 	if ind == -1 {
 		return false, false, ""
 	}
+
 	addr = s[ind+1:]
+	addr = internal.GetAddr(addr)
 	return
 }
 
diff --git a/example/del-keys-without-ttl/go.mod b/example/del-keys-without-ttl/go.mod
index c42bcec8a..468d0a54f 100644
--- a/example/del-keys-without-ttl/go.mod
+++ b/example/del-keys-without-ttl/go.mod
@@ -5,7 +5,7 @@ go 1.18
 replace github.com/redis/go-redis/v9 => ../..
 
 require (
-	github.com/redis/go-redis/v9 v9.0.5
+	github.com/redis/go-redis/v9 v9.5.3
 	go.uber.org/zap v1.24.0
 )
 
diff --git a/example/del-keys-without-ttl/go.sum b/example/del-keys-without-ttl/go.sum
index 4f8d9abbf..e426a762b 100644
--- a/example/del-keys-without-ttl/go.sum
+++ b/example/del-keys-without-ttl/go.sum
@@ -1,6 +1,6 @@
 github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
+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.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
diff --git a/example/del-keys-without-ttl/main.go b/example/del-keys-without-ttl/main.go
index 549d78e21..d2f85d4e8 100644
--- a/example/del-keys-without-ttl/main.go
+++ b/example/del-keys-without-ttl/main.go
@@ -6,8 +6,9 @@ import (
 	"sync"
 	"time"
 
-	"github.com/redis/go-redis/v9"
 	"go.uber.org/zap"
+
+	"github.com/redis/go-redis/v9"
 )
 
 func main() {
diff --git a/example/hll/go.mod b/example/hll/go.mod
index 67fcec46b..0126764ef 100644
--- a/example/hll/go.mod
+++ b/example/hll/go.mod
@@ -4,7 +4,7 @@ go 1.18
 
 replace github.com/redis/go-redis/v9 => ../..
 
-require github.com/redis/go-redis/v9 v9.0.5
+require github.com/redis/go-redis/v9 v9.5.3
 
 require (
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
diff --git a/example/hll/go.sum b/example/hll/go.sum
index 813d21fd9..0e92df5e7 100644
--- a/example/hll/go.sum
+++ b/example/hll/go.sum
@@ -1,5 +1,5 @@
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
+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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
diff --git a/example/lua-scripting/go.mod b/example/lua-scripting/go.mod
index 4a4f341cc..3f4c29d12 100644
--- a/example/lua-scripting/go.mod
+++ b/example/lua-scripting/go.mod
@@ -1,10 +1,10 @@
-module github.com/redis/go-redis/example/redis-bloom
+module github.com/redis/go-redis/example/lua-scripting
 
 go 1.18
 
 replace github.com/redis/go-redis/v9 => ../..
 
-require github.com/redis/go-redis/v9 v9.0.5
+require github.com/redis/go-redis/v9 v9.5.3
 
 require (
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
diff --git a/example/lua-scripting/go.sum b/example/lua-scripting/go.sum
index 813d21fd9..0e92df5e7 100644
--- a/example/lua-scripting/go.sum
+++ b/example/lua-scripting/go.sum
@@ -1,5 +1,5 @@
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
+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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
diff --git a/example/otel/config/otel-collector.yaml b/example/otel/config/otel-collector.yaml
index 3e64cb455..2cb130dd6 100644
--- a/example/otel/config/otel-collector.yaml
+++ b/example/otel/config/otel-collector.yaml
@@ -30,18 +30,18 @@ receivers:
 processors:
   resourcedetection:
     detectors: ['system']
+  cumulativetodelta:
   batch:
     send_batch_size: 10000
     timeout: 10s
 
 exporters:
-  logging:
-    logLevel: debug
-  otlp:
-    endpoint: uptrace:14317
+  otlp/uptrace:
+    endpoint: http://uptrace:14317
     tls:
       insecure: true
     headers: { 'uptrace-dsn': 'http://project2_secret_token@localhost:14317/2' }
+  debug:
 
 service:
   # telemetry:
@@ -51,18 +51,18 @@ service:
     traces:
       receivers: [otlp, jaeger]
       processors: [batch]
-      exporters: [otlp, logging]
+      exporters: [otlp/uptrace]
     metrics:
       receivers: [otlp]
-      processors: [batch]
-      exporters: [otlp]
+      processors: [cumulativetodelta, batch]
+      exporters: [otlp/uptrace]
     metrics/hostmetrics:
       receivers: [hostmetrics, redis]
-      processors: [batch, resourcedetection]
-      exporters: [otlp]
+      processors: [cumulativetodelta, batch, resourcedetection]
+      exporters: [otlp/uptrace]
     logs:
       receivers: [otlp]
       processors: [batch]
-      exporters: [otlp]
+      exporters: [otlp/uptrace]
 
   extensions: [health_check, pprof, zpages]
diff --git a/example/otel/docker-compose.yml b/example/otel/docker-compose.yml
index 92c7958d2..4244792a9 100644
--- a/example/otel/docker-compose.yml
+++ b/example/otel/docker-compose.yml
@@ -2,7 +2,7 @@ version: '3'
 
 services:
   clickhouse:
-    image: clickhouse/clickhouse-server:22.10
+    image: clickhouse/clickhouse-server:23.7
     restart: on-failure
     environment:
       CLICKHOUSE_DB: uptrace
@@ -36,7 +36,7 @@ services:
       - '5432:5432'
 
   uptrace:
-    image: 'uptrace/uptrace:1.5.0'
+    image: 'uptrace/uptrace:1.6.2'
     #image: 'uptrace/uptrace-dev:latest'
     restart: on-failure
     volumes:
@@ -51,7 +51,7 @@ services:
         condition: service_healthy
 
   otelcol:
-    image: otel/opentelemetry-collector-contrib:0.70.0
+    image: otel/opentelemetry-collector-contrib:0.91.0
     restart: on-failure
     volumes:
       - ./config/otel-collector.yaml:/etc/otelcol-contrib/config.yaml
diff --git a/example/otel/go.mod b/example/otel/go.mod
index 5f64d05e9..2beb75db9 100644
--- a/example/otel/go.mod
+++ b/example/otel/go.mod
@@ -9,37 +9,37 @@ replace github.com/redis/go-redis/extra/redisotel/v9 => ../../extra/redisotel
 replace github.com/redis/go-redis/extra/rediscmd/v9 => ../../extra/rediscmd
 
 require (
-	github.com/redis/go-redis/extra/redisotel/v9 v9.0.5
-	github.com/redis/go-redis/v9 v9.0.5
-	github.com/uptrace/uptrace-go v1.16.0
-	go.opentelemetry.io/otel v1.16.0
+	github.com/redis/go-redis/extra/redisotel/v9 v9.5.3
+	github.com/redis/go-redis/v9 v9.5.3
+	github.com/uptrace/uptrace-go v1.21.0
+	go.opentelemetry.io/otel v1.22.0
 )
 
 require (
 	github.com/cenkalti/backoff/v4 v4.2.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/go-logr/logr v1.2.4 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/golang/protobuf v1.5.3 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.2 // indirect
-	github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5 // indirect
-	go.opentelemetry.io/contrib/instrumentation/runtime v0.42.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.39.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.39.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.16.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.16.0 // indirect
-	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.16.0 // indirect
-	go.opentelemetry.io/otel/metric v1.16.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.16.0 // indirect
-	go.opentelemetry.io/otel/sdk/metric v0.39.0 // indirect
-	go.opentelemetry.io/otel/trace v1.16.0 // indirect
-	go.opentelemetry.io/proto/otlp v0.19.0 // indirect
-	golang.org/x/net v0.10.0 // indirect
-	golang.org/x/sys v0.8.0 // indirect
-	golang.org/x/text v0.9.0 // indirect
-	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 // indirect
-	google.golang.org/grpc v1.55.0 // indirect
-	google.golang.org/protobuf v1.30.0 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 // indirect
+	github.com/redis/go-redis/extra/rediscmd/v9 v9.5.3 // indirect
+	go.opentelemetry.io/contrib/instrumentation/runtime v0.46.1 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.44.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0 // indirect
+	go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.21.0 // indirect
+	go.opentelemetry.io/otel/metric v1.22.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.22.0 // indirect
+	go.opentelemetry.io/otel/sdk/metric v1.21.0 // indirect
+	go.opentelemetry.io/otel/trace v1.22.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.0.0 // indirect
+	golang.org/x/net v0.20.0 // indirect
+	golang.org/x/sys v0.16.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
+	google.golang.org/genproto v0.0.0-20240108191215-35c7eff3a6b1 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 // indirect
+	google.golang.org/grpc v1.60.1 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 )
diff --git a/example/otel/go.sum b/example/otel/go.sum
index 4ba59e440..4a481d6ef 100644
--- a/example/otel/go.sum
+++ b/example/otel/go.sum
@@ -1,466 +1,68 @@
-cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
-cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
-cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
-cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
-cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
-cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
-cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
-cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
-cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
-cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
-cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
-cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
-cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
-cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
-cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
-cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
-cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
-cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
-cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
-cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
-cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
-cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
-cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
-cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
-cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
-cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
-cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
-cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
-cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
-cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
-dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
-github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/ginkgo/v2 v2.7.0/go.mod h1:AiKlXPm7ItEHNc/2+OkrNG4E0ITzojb9/xWzvQ9XZ9w=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
-github.com/bsm/gomega v1.26.0/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/cenkalti/backoff/v4 v4.2.1 h1:y4OZtCnogmCPw98Zjyt5a6+QwPLGkiQsYW5oUqylYbM=
 github.com/cenkalti/backoff/v4 v4.2.1/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
-github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
-github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
-github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
-github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
-github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
-github.com/cncf/udpa/go v0.0.0-20210930031921-04548b0d99d4/go.mod h1:6pvJx4me5XPnfI9Z40ddWsdw2W/uZgQLFXToKeRcDiI=
-github.com/cncf/xds/go v0.0.0-20210312221358-fbca930ec8ed/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210805033703-aa0b78936158/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20210922020428-25de7278fc84/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-github.com/cncf/xds/go v0.0.0-20211011173535-cb28da3451f1/go.mod h1:eXthEFrGJvWHgFFCl3hGmgk+/aYT6PnTQLykKQRLhEs=
-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/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/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
-github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
-github.com/envoyproxy/go-control-plane v0.9.9-0.20210512163311-63b5d3c536b0/go.mod h1:hliV/p42l8fGbc6Y9bQ70uLwIvmJyVE5k4iMKlh8wCQ=
-github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.mod h1:AFq3mo9L8Lqqiid3OhADV3RfLJnjiw63cSpi+fDTRC0=
-github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
-github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
-github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
-github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
-github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/glog v1.0.0/go.mod h1:EWib/APOK0SL3dFbYqvxE3UYd8E6s1ouQ7iEp/0LWV4=
-github.com/golang/glog v1.1.1 h1:jxpi2eWoU84wbX9iIEyAeeoac3FLuifZpY9tcNUD9kw=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
-github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
-github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
-github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
-github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
-github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
-github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
-github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
-github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
-github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
-github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
-github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
-github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
-github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
-github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
-github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
-github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
-github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.7.0/go.mod h1:hgWBS7lorOAVIJEQMi4ZsPv9hVvWI6+ch50m39Pf2Ks=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.2 h1:gDLXvp5S9izjldquuoAhDzccbskOL6tDC5jMSyx3zxE=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.15.2/go.mod h1:7pdNwVWBBHGiCxa9lAszqCJMbfTISJ7oMftp8+UGV08=
-github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
-github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0 h1:Wqo399gCIufwto+VfwCSvsnfGpF/w5E9CNxSwbpD6No=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.19.0/go.mod h1:qmOFXW2epJhM0qSnUUYpldc7gVz2KMQwJ/QYCDIa7XU=
 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/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
-github.com/uptrace/uptrace-go v1.16.0 h1:yB9vt1hBYYoXWExNx0okubLOjd339d7lH+/5o+Lp+MY=
-github.com/uptrace/uptrace-go v1.16.0/go.mod h1:Ssc5wLpoL+9V0qkT5FtrIiru9SY4xb7q1UVLjSpxpCg=
-github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
-go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
-go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opentelemetry.io/contrib/instrumentation/runtime v0.42.0 h1:EbmAUG9hEAMXyfWEasIt2kmh/WmXUznUksChApTgBGc=
-go.opentelemetry.io/contrib/instrumentation/runtime v0.42.0/go.mod h1:rD9feqRYP24P14t5kmhNMqsqm1jvKmpx2H2rKVw52V8=
-go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s=
-go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4=
-go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0 h1:t4ZwRPU+emrcvM2e9DHd0Fsf0JTPVcbfa/BhTDF03d0=
-go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.16.0/go.mod h1:vLarbg68dH2Wa77g71zmKQqlQ8+8Rq3GRG31uc0WcWI=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.39.0 h1:f6BwB2OACc3FCbYVznctQ9V6KK7Vq6CjmYXJ7DeSs4E=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric v0.39.0/go.mod h1:UqL5mZ3qs6XYhDnZaW1Ps4upD+PX6LipH40AoeuIlwU=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.39.0 h1:rm+Fizi7lTM2UefJ1TO347fSRcwmIsUAaZmYmIGBRAo=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.39.0/go.mod h1:sWFbI3jJ+6JdjOVepA5blpv/TJ20Hw+26561iMbWcwU=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.16.0 h1:cbsD4cUcviQGXdw8+bo5x2wazq10SKz8hEbtCRPcU78=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.16.0/go.mod h1:JgXSGah17croqhJfhByOLVY719k1emAXC8MVhCIJlRs=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.16.0 h1:TVQp/bboR4mhZSav+MdgXB8FaRho1RC8UwVn3T0vjVc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.16.0/go.mod h1:I33vtIe0sR96wfrUcilIzLoA3mLHhRmz9S9Te0S3gDo=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.16.0 h1:+XWJd3jf75RXJq29mxbuXhCXFDG3S3R4vBUeSI2P7tE=
-go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.16.0/go.mod h1:hqgzBPTf4yONMFgdZvL/bK42R/iinTyVQtiWihs3SZc=
-go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo=
-go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4=
-go.opentelemetry.io/otel/sdk v1.16.0 h1:Z1Ok1YsijYL0CSJpHt4cS3wDDh7p572grzNrBMiMWgE=
-go.opentelemetry.io/otel/sdk v1.16.0/go.mod h1:tMsIuKXuuIWPBAOrH+eHtvhTL+SntFtXF9QD68aP6p4=
-go.opentelemetry.io/otel/sdk/metric v0.39.0 h1:Kun8i1eYf48kHH83RucG93ffz0zGV1sh46FAScOTuDI=
-go.opentelemetry.io/otel/sdk/metric v0.39.0/go.mod h1:piDIRgjcK7u0HCL5pCA4e74qpK/jk3NiUoAHATVAmiI=
-go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs=
-go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0=
-go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw=
-go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U=
-go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
-golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
-golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
-golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
-golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
-golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
-golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
-golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
-golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
-golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
-golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
-golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
-golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
-golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
-golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
-golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
-golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
-golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
-golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
-golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
-golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
-golang.org/x/oauth2 v0.0.0-20211104180415-d3ed0bb246c8/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
-golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-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.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
-golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
-golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
-golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
-golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
-golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
-golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
-golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/uptrace/uptrace-go v1.21.0 h1:oJoUjhiVT7aiuoG6B3ClVHtJozLn3cK9hQt8U5dQO1M=
+github.com/uptrace/uptrace-go v1.21.0/go.mod h1:/aXAFGKOqeAFBqWa1xtzLnGX2xJm1GScqz9NJ0TJjLM=
+go.opentelemetry.io/contrib/instrumentation/runtime v0.46.1 h1:m9ReioVPIffxjJlGNRd0d5poy+9oTro3D+YbiEzUDOc=
+go.opentelemetry.io/contrib/instrumentation/runtime v0.46.1/go.mod h1:CANkrsXNzqOKXfOomu2zhOmc1/J5UZK9SGjrat6ZCG0=
+go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y=
+go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.44.0 h1:jd0+5t/YynESZqsSyPz+7PAFdEop0dlN0+PkyHYo8oI=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v0.44.0/go.mod h1:U707O40ee1FpQGyhvqnzmCJm1Wh6OX6GGBVn0E6Uyyk=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0 h1:cl5P5/GIfFh4t6xyruOgJP5QiA1pw4fYYdv6nc6CBWw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.21.0/go.mod h1:zgBdWWAu7oEEMC06MMKc5NLbA/1YDXV1sMpSqEeLQLg=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0 h1:tIqheXEFWAZ7O8A7m+J0aPTmpJN3YQ7qetUAdkkkKpk=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.21.0/go.mod h1:nUeKExfxAQVbiVFn32YXpXZZHZ61Cc3s3Rn1pDBGAb0=
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.21.0 h1:VhlEQAPp9R1ktYfrPk5SOryw1e9LDDTZCbIPFrho0ec=
+go.opentelemetry.io/otel/exporters/stdout/stdouttrace v1.21.0/go.mod h1:kB3ufRbfU+CQ4MlUcqtW8Z7YEOBeK2DJ6CmR5rYYF3E=
+go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg=
+go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY=
+go.opentelemetry.io/otel/sdk v1.22.0 h1:6coWHw9xw7EfClIC/+O31R8IY3/+EiRFHevmHafB2Gw=
+go.opentelemetry.io/otel/sdk v1.22.0/go.mod h1:iu7luyVGYovrRpe2fmj3CVKouQNdTOkxtLzPvPz1DOc=
+go.opentelemetry.io/otel/sdk/metric v1.21.0 h1:smhI5oD714d6jHE6Tie36fPx4WDFIg+Y6RfAY4ICcR0=
+go.opentelemetry.io/otel/sdk/metric v1.21.0/go.mod h1:FJ8RAsoPGv/wYMgBdUJXOm+6pzFY3YdljnXtv1SBE8Q=
+go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0=
+go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo=
+go.opentelemetry.io/proto/otlp v1.0.0 h1:T0TX0tmXU8a3CbNXzEKGeU5mIVOdf0oykP+u2lIVU/I=
+go.opentelemetry.io/proto/otlp v1.0.0/go.mod h1:Sy6pihPLfYHkr3NkUbEhGHFhINUSI/v80hjKIs5JXpM=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
-google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
-google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
-google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
-google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
-google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
-google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
-google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
-google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
-google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
-google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
-google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
-google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
-google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
-google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
-google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
-google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
-google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
-google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20211118181313-81c1377c94b1/go.mod h1:5CzLGKJ67TSI2B9POpiiyGha0AjJvZIUgRMt1dSmuhc=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1 h1:KpwkzHKEF7B9Zxg18WzOa7djJ+Ha5DzthMyZYQfEn2A=
-google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1/go.mod h1:nKE/iIaLqn2bQwXBg8f1g2Ylh6r5MN5CmZvuzZCgsCU=
-google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
-google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
-google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
-google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
-google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
-google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
-google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
-google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
-google.golang.org/grpc v1.40.0/go.mod h1:ogyxbiOoUXAkP+4+xa6PZSE9DZgIHtSpzjDTB9KAK34=
-google.golang.org/grpc v1.42.0/go.mod h1:k+4IHHFw41K8+bbowsex27ge2rCb65oeWqe4jJ590SU=
-google.golang.org/grpc v1.55.0 h1:3Oj82/tFSCeUrRTg/5E/7d/W5A1tj6Ky1ABAuZuv5ag=
-google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8=
-google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
-google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
-google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
-google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
-google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
-google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/genproto v0.0.0-20240108191215-35c7eff3a6b1 h1:/IWabOtPziuXTEtI1KYCpM6Ss7vaAkeMxk+uXV/xvZs=
+google.golang.org/genproto v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:+Rvu7ElI+aLzyDQhpHMFMMltsD6m7nqpuWDd2CwJw3k=
+google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1 h1:OPXtXn7fNMaXwO3JvOmF1QyTc00jsSFFz1vXXBOdCDo=
+google.golang.org/genproto/googleapis/api v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:B5xPO//w8qmBDjGReYLpR6UJPnkldGkCSMoH/2vxJeg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1 h1:gphdwh0npgs8elJ4T6J+DQJHPVF7RsuJHCfwztUb4J4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240108191215-35c7eff3a6b1/go.mod h1:daQN87bsDqDoe316QbbvX60nMoJQa4r6Ds0ZuoAe5yA=
+google.golang.org/grpc v1.60.1 h1:26+wFr+cNqSGFcOXcabYC0lUVJVRa2Sb2ortSK7VrEU=
+google.golang.org/grpc v1.60.1/go.mod h1:OlCHIeLYqSSsLi6i49B5QGdzaMZK9+M7LXN2FKz4eGM=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.27.1/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
-honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
-rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
-rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
-rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/example/otel/uptrace.yml b/example/otel/uptrace.yml
index 0fa28bcac..90ecbf750 100644
--- a/example/otel/uptrace.yml
+++ b/example/otel/uptrace.yml
@@ -22,12 +22,16 @@ ch:
   password:
   database: uptrace
 
+  # Maximum query execution time.
+  max_execution_time: 30s
+
   # TLS configuration. Uncomment to enable.
   # tls:
   #   insecure_skip_verify: true
 
-  # Maximum query execution time.
-  max_execution_time: 30s
+  # TLS configuration. Uncomment to enable.
+  # tls:
+  #   insecure_skip_verify: true # only for self-signed certificates
 
 ##
 ## PostgreSQL db that is used to store metadata such us metric names, dashboards, alerts,
@@ -49,13 +53,15 @@ projects:
     # Token grants write access to the project. Keep a secret.
     token: project1_secret_token
     pinned_attrs:
-      - service.name
-      - host.name
-      - deployment.environment
+      - service_name
+      - host_name
+      - deployment_environment
     # Group spans by deployment.environment attribute.
     group_by_env: false
     # Group funcs spans by service.name attribute.
     group_funcs_by_service: false
+    # Enable prom_compat if you want to use the project as a Prometheus datasource in Grafana.
+    prom_compat: true
 
   # Other projects can be used to monitor your applications.
   # To monitor micro-services or multiple related services, use a single project.
@@ -63,13 +69,12 @@ projects:
     name: My project
     token: project2_secret_token
     pinned_attrs:
-      - service.name
-      - host.name
-      - deployment.environment
-    # Group spans by deployment.environment attribute.
+      - service_name
+      - host_name
+      - deployment_environment
     group_by_env: false
-    # Group funcs spans by service.name attribute.
     group_funcs_by_service: false
+    prom_compat: true
 
 ##
 ## Create metrics from spans and events.
@@ -79,30 +84,30 @@ metrics_from_spans:
     description: Spans duration (excluding events)
     instrument: histogram
     unit: microseconds
-    value: .duration / 1000
+    value: _duration / 1000
     attrs:
-      - .system
-      - .group_id
-      - service.name
-      - host.name
-      - .status_code
+      - _system
+      - _group_id
+      - service_name
+      - host_name
+      - _status_code
     annotations:
-      - display.name
-    where: .event_name = ''
+      - display_name
+    where: _event_name = ''
 
   - name: uptrace.tracing.events
     description: Events count (excluding spans)
     instrument: counter
     unit: 1
-    value: .count
+    value: _count
     attrs:
-      - .system
-      - .group_id
-      - .name
-      - host.name
+      - _system
+      - _group_id
+      - _name
+      - host_name
     annotations:
-      - display.name
-    where: .is_event = 1
+      - display_name
+    where: _is_event = 1
 
 ##
 ## To require authentication, uncomment one of the following sections.
@@ -158,12 +163,12 @@ ch_schema:
 
   spans:
     # Delete spans data after 30 days.
-    ttl_delete: 30 DAY
+    ttl_delete: 7 DAY
     storage_policy: 'default'
 
   metrics:
     # Delete metrics data after 90 days.
-    ttl_delete: 90 DAY
+    ttl_delete: 30 DAY
     storage_policy: 'default'
 
 ##
@@ -173,16 +178,14 @@ listen:
   # OTLP/gRPC API.
   grpc:
     addr: ':14317'
-    # tls:
-    #   cert_file: config/tls/uptrace.crt
-    #   key_file: config/tls/uptrace.key
 
   # OTLP/HTTP API and Uptrace API with UI.
   http:
     addr: ':14318'
-    # tls:
-    #   cert_file: config/tls/uptrace.crt
-    #   key_file: config/tls/uptrace.key
+
+  # tls:
+  #   cert_file: config/tls/uptrace.crt
+  #   key_file: config/tls/uptrace.key
 
 ##
 ## Various options for Uptrace UI.
@@ -190,8 +193,6 @@ listen:
 site:
   # Overrides public URL for Vue-powered UI in case you put Uptrace behind a proxy.
   #addr: 'https://uptrace.mydomain.com'
-  # The base path for the Vue-powered UI in case you serve Uptrace UI behind a sub path.
-  path: '/'
 
 ##
 ## Spans processing options.
@@ -210,9 +211,9 @@ spans:
 metrics:
   # List of attributes to drop for being noisy.
   drop_attrs:
-    - telemetry.sdk.language
-    - telemetry.sdk.name
-    - telemetry.sdk.version
+    - telemetry_sdk_language
+    - telemetry_sdk_name
+    - telemetry_sdk_version
 
   # The size of the Go chan used to buffer incoming measures.
   # If the buffer is full, Uptrace starts to drop measures.
@@ -226,7 +227,12 @@ metrics:
 ## Uptrace sends internal telemetry here. Defaults to listen.grpc.addr.
 ##
 uptrace_go:
+  # Enabled by default.
+  #disabled: true
+
+  # Defaults to the first projects.
   # dsn: http://project1_secret_token@localhost:14317/1
+
   # tls:
   #   cert_file: config/tls/uptrace.crt
   #   key_file: config/tls/uptrace.key
diff --git a/example/redis-bloom/go.mod b/example/redis-bloom/go.mod
index 4a4f341cc..09fb5bed4 100644
--- a/example/redis-bloom/go.mod
+++ b/example/redis-bloom/go.mod
@@ -4,7 +4,7 @@ go 1.18
 
 replace github.com/redis/go-redis/v9 => ../..
 
-require github.com/redis/go-redis/v9 v9.0.5
+require github.com/redis/go-redis/v9 v9.5.3
 
 require (
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
diff --git a/example/redis-bloom/go.sum b/example/redis-bloom/go.sum
index 813d21fd9..0e92df5e7 100644
--- a/example/redis-bloom/go.sum
+++ b/example/redis-bloom/go.sum
@@ -1,5 +1,5 @@
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
+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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
diff --git a/example/scan-struct/go.mod b/example/scan-struct/go.mod
index 6eedff4e8..c01e31293 100644
--- a/example/scan-struct/go.mod
+++ b/example/scan-struct/go.mod
@@ -6,7 +6,7 @@ replace github.com/redis/go-redis/v9 => ../..
 
 require (
 	github.com/davecgh/go-spew v1.1.1
-	github.com/redis/go-redis/v9 v9.0.5
+	github.com/redis/go-redis/v9 v9.5.3
 )
 
 require (
diff --git a/example/scan-struct/go.sum b/example/scan-struct/go.sum
index 387a78861..6274a65f6 100644
--- a/example/scan-struct/go.sum
+++ b/example/scan-struct/go.sum
@@ -1,5 +1,5 @@
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
+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.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
diff --git a/example/scan-struct/main.go b/example/scan-struct/main.go
index 9d270b530..cc877b847 100644
--- a/example/scan-struct/main.go
+++ b/example/scan-struct/main.go
@@ -11,6 +11,7 @@ import (
 type Model struct {
 	Str1    string   `redis:"str1"`
 	Str2    string   `redis:"str2"`
+	Bytes   []byte   `redis:"bytes"`
 	Int     int      `redis:"int"`
 	Bool    bool     `redis:"bool"`
 	Ignored struct{} `redis:"-"`
@@ -22,6 +23,7 @@ func main() {
 	rdb := redis.NewClient(&redis.Options{
 		Addr: ":6379",
 	})
+	_ = rdb.FlushDB(ctx).Err()
 
 	// Set some fields.
 	if _, err := rdb.Pipelined(ctx, func(rdb redis.Pipeliner) error {
@@ -29,6 +31,7 @@ func main() {
 		rdb.HSet(ctx, "key", "str2", "world")
 		rdb.HSet(ctx, "key", "int", 123)
 		rdb.HSet(ctx, "key", "bool", 1)
+		rdb.HSet(ctx, "key", "bytes", []byte("this is bytes !"))
 		return nil
 	}); err != nil {
 		panic(err)
@@ -47,5 +50,28 @@ func main() {
 	}
 
 	spew.Dump(model1)
+	// Output:
+	// (main.Model) {
+	// 	Str1: (string) (len=5) "hello",
+	// 	Str2: (string) (len=5) "world",
+	// 	Bytes: ([]uint8) (len=15 cap=16) {
+	// 	 00000000  74 68 69 73 20 69 73 20  62 79 74 65 73 20 21     |this is bytes !|
+	// 	},
+	// 	Int: (int) 123,
+	// 	Bool: (bool) true,
+	// 	Ignored: (struct {}) {
+	// 	}
+	// }
+
 	spew.Dump(model2)
+	// Output:
+	// (main.Model) {
+	// 	Str1: (string) (len=5) "hello",
+	// 	Str2: (string) "",
+	// 	Bytes: ([]uint8) <nil>,
+	// 	Int: (int) 123,
+	// 	Bool: (bool) false,
+	// 	Ignored: (struct {}) {
+	// 	}
+	// }
 }
diff --git a/example_test.go b/example_test.go
index 84f0ba91e..28d14b65a 100644
--- a/example_test.go
+++ b/example_test.go
@@ -154,7 +154,7 @@ func ExampleClient() {
 	// missing_key does not exist
 }
 
-func ExampleConn() {
+func ExampleConn_name() {
 	conn := rdb.Conn()
 
 	err := conn.ClientSetName(ctx, "foobar").Err()
@@ -175,6 +175,28 @@ func ExampleConn() {
 	// Output: foobar
 }
 
+func ExampleConn_client_setInfo_libraryVersion() {
+	conn := rdb.Conn()
+
+	err := conn.ClientSetInfo(ctx, redis.WithLibraryVersion("1.2.3")).Err()
+	if err != nil {
+		panic(err)
+	}
+
+	// Open other connections.
+	for i := 0; i < 10; i++ {
+		go rdb.Ping(ctx)
+	}
+
+	s, err := conn.ClientInfo(ctx).Result()
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(s.LibVer)
+	// Output: 1.2.3
+}
+
 func ExampleClient_Set() {
 	// Last argument is expiration. Zero means the key has no
 	// expiration time.
@@ -460,7 +482,7 @@ func ExampleClient_Watch() {
 				return err
 			}
 
-			// Actual opperation (local in optimistic lock).
+			// Actual operation (local in optimistic lock).
 			n++
 
 			// Operation is committed only if the watched keys remain unchanged.
@@ -657,6 +679,11 @@ func ExampleNewUniversalClient_cluster() {
 }
 
 func ExampleClient_SlowLogGet() {
+	if RECluster {
+		// skip slowlog test for cluster
+		fmt.Println(2)
+		return
+	}
 	const key = "slowlog-log-slower-than"
 
 	old := rdb.ConfigGet(ctx, key).Val()
diff --git a/extra/rediscensus/go.mod b/extra/rediscensus/go.mod
index be64747c5..d623cef36 100644
--- a/extra/rediscensus/go.mod
+++ b/extra/rediscensus/go.mod
@@ -1,14 +1,19 @@
 module github.com/redis/go-redis/extra/rediscensus/v9
 
-go 1.15
+go 1.19
 
 replace github.com/redis/go-redis/v9 => ../..
 
 replace github.com/redis/go-redis/extra/rediscmd/v9 => ../rediscmd
 
 require (
-	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5
-	github.com/redis/go-redis/v9 v9.0.5
+	github.com/redis/go-redis/extra/rediscmd/v9 v9.5.3
+	github.com/redis/go-redis/v9 v9.5.3
 	go.opencensus.io v0.24.0
 )
+
+require (
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
+)
diff --git a/extra/rediscensus/go.sum b/extra/rediscensus/go.sum
index 697db5f85..cf8f90721 100644
--- a/extra/rediscensus/go.sum
+++ b/extra/rediscensus/go.sum
@@ -1,9 +1,7 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/ginkgo/v2 v2.7.0/go.mod h1:AiKlXPm7ItEHNc/2+OkrNG4E0ITzojb9/xWzvQ9XZ9w=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
-github.com/bsm/gomega v1.26.0/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
 github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
diff --git a/extra/rediscmd/go.mod b/extra/rediscmd/go.mod
index a31ccc489..a035c8694 100644
--- a/extra/rediscmd/go.mod
+++ b/extra/rediscmd/go.mod
@@ -1,11 +1,16 @@
 module github.com/redis/go-redis/extra/rediscmd/v9
 
-go 1.15
+go 1.19
 
 replace github.com/redis/go-redis/v9 => ../..
 
 require (
-	github.com/bsm/ginkgo/v2 v2.7.0
-	github.com/bsm/gomega v1.26.0
-	github.com/redis/go-redis/v9 v9.0.5
+	github.com/bsm/ginkgo/v2 v2.12.0
+	github.com/bsm/gomega v1.27.10
+	github.com/redis/go-redis/v9 v9.5.3
+)
+
+require (
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 )
diff --git a/extra/rediscmd/go.sum b/extra/rediscmd/go.sum
index 33f9e16b4..21b4f64ee 100644
--- a/extra/rediscmd/go.sum
+++ b/extra/rediscmd/go.sum
@@ -1,7 +1,7 @@
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/ginkgo/v2 v2.7.0/go.mod h1:AiKlXPm7ItEHNc/2+OkrNG4E0ITzojb9/xWzvQ9XZ9w=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
-github.com/bsm/gomega v1.26.0/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
 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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
diff --git a/extra/redisotel/config.go b/extra/redisotel/config.go
index c24f89672..c02ee0b31 100644
--- a/extra/redisotel/config.go
+++ b/extra/redisotel/config.go
@@ -4,7 +4,7 @@ import (
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/metric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
 	"go.opentelemetry.io/otel/trace"
 )
 
diff --git a/extra/redisotel/go.mod b/extra/redisotel/go.mod
index f18d628c1..587d3bc3a 100644
--- a/extra/redisotel/go.mod
+++ b/extra/redisotel/go.mod
@@ -7,18 +7,18 @@ replace github.com/redis/go-redis/v9 => ../..
 replace github.com/redis/go-redis/extra/rediscmd/v9 => ../rediscmd
 
 require (
-	github.com/redis/go-redis/extra/rediscmd/v9 v9.0.5
-	github.com/redis/go-redis/v9 v9.0.5
-	go.opentelemetry.io/otel v1.16.0
-	go.opentelemetry.io/otel/metric v1.16.0
-	go.opentelemetry.io/otel/sdk v1.16.0
-	go.opentelemetry.io/otel/trace v1.16.0
+	github.com/redis/go-redis/extra/rediscmd/v9 v9.5.3
+	github.com/redis/go-redis/v9 v9.5.3
+	go.opentelemetry.io/otel v1.22.0
+	go.opentelemetry.io/otel/metric v1.22.0
+	go.opentelemetry.io/otel/sdk v1.22.0
+	go.opentelemetry.io/otel/trace v1.22.0
 )
 
 require (
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/go-logr/logr v1.2.4 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/sys v0.16.0 // indirect
 )
diff --git a/extra/redisotel/go.sum b/extra/redisotel/go.sum
index 22049451c..9eb9bcd4e 100644
--- a/extra/redisotel/go.sum
+++ b/extra/redisotel/go.sum
@@ -1,28 +1,26 @@
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/ginkgo/v2 v2.7.0/go.mod h1:AiKlXPm7ItEHNc/2+OkrNG4E0ITzojb9/xWzvQ9XZ9w=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
-github.com/bsm/gomega v1.26.0/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+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.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 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/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
-github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
-go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s=
-go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4=
-go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo=
-go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4=
-go.opentelemetry.io/otel/sdk v1.16.0 h1:Z1Ok1YsijYL0CSJpHt4cS3wDDh7p572grzNrBMiMWgE=
-go.opentelemetry.io/otel/sdk v1.16.0/go.mod h1:tMsIuKXuuIWPBAOrH+eHtvhTL+SntFtXF9QD68aP6p4=
-go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs=
-go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0=
-golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+go.opentelemetry.io/otel v1.22.0 h1:xS7Ku+7yTFvDfDraDIJVpw7XPyuHlB9MCiqqX5mcJ6Y=
+go.opentelemetry.io/otel v1.22.0/go.mod h1:eoV4iAi3Ea8LkAEI9+GFT44O6T/D0GWAVFyZVCC6pMI=
+go.opentelemetry.io/otel/metric v1.22.0 h1:lypMQnGyJYeuYPhOM/bgjbFM6WE44W1/T45er4d8Hhg=
+go.opentelemetry.io/otel/metric v1.22.0/go.mod h1:evJGjVpZv0mQ5QBRJoBF64yMuOf4xCWdXjK8pzFvliY=
+go.opentelemetry.io/otel/sdk v1.22.0 h1:6coWHw9xw7EfClIC/+O31R8IY3/+EiRFHevmHafB2Gw=
+go.opentelemetry.io/otel/sdk v1.22.0/go.mod h1:iu7luyVGYovrRpe2fmj3CVKouQNdTOkxtLzPvPz1DOc=
+go.opentelemetry.io/otel/trace v1.22.0 h1:Hg6pPujv0XG9QaVbGOBVHunyuLcCC3jN7WEhPx83XD0=
+go.opentelemetry.io/otel/trace v1.22.0/go.mod h1:RbbHXVqKES9QhzZq/fE5UnOSILqRt40a21sPw2He1xo=
+golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU=
+golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
diff --git a/extra/redisotel/metrics.go b/extra/redisotel/metrics.go
index 695c7ee3e..915838f34 100644
--- a/extra/redisotel/metrics.go
+++ b/extra/redisotel/metrics.go
@@ -6,10 +6,11 @@ import (
 	"net"
 	"time"
 
-	"github.com/redis/go-redis/v9"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/metric"
+
+	"github.com/redis/go-redis/v9"
 )
 
 // InstrumentMetrics starts reporting OpenTelemetry Metrics.
@@ -192,11 +193,13 @@ func (mh *metricsHook) DialHook(hook redis.DialHook) redis.DialHook {
 
 		conn, err := hook(ctx, network, addr)
 
+		dur := time.Since(start)
+
 		attrs := make([]attribute.KeyValue, 0, len(mh.attrs)+1)
 		attrs = append(attrs, mh.attrs...)
 		attrs = append(attrs, statusAttr(err))
 
-		mh.createTime.Record(ctx, milliseconds(time.Since(start)), metric.WithAttributes(attrs...))
+		mh.createTime.Record(ctx, milliseconds(dur), metric.WithAttributes(attrs...))
 		return conn, err
 	}
 }
diff --git a/extra/redisotel/redisotel_test.go b/extra/redisotel/redisotel_test.go
index fd75361e8..b1ad5ca43 100644
--- a/extra/redisotel/redisotel_test.go
+++ b/extra/redisotel/redisotel_test.go
@@ -13,21 +13,21 @@ import (
 	"github.com/redis/go-redis/v9"
 )
 
-type providerFunc func(name string, opts ...trace.TracerOption) trace.Tracer
+type providerFunc func(name string, opts ...trace.TracerOption) trace.TracerProvider
 
-func (fn providerFunc) Tracer(name string, opts ...trace.TracerOption) trace.Tracer {
+func (fn providerFunc) TracerProvider(name string, opts ...trace.TracerOption) trace.TracerProvider {
 	return fn(name, opts...)
 }
 
 func TestNewWithTracerProvider(t *testing.T) {
 	invoked := false
 
-	tp := providerFunc(func(name string, opts ...trace.TracerOption) trace.Tracer {
+	tp := providerFunc(func(name string, opts ...trace.TracerOption) trace.TracerProvider {
 		invoked = true
-		return otel.GetTracerProvider().Tracer(name, opts...)
+		return otel.GetTracerProvider()
 	})
 
-	_ = newTracingHook("", WithTracerProvider(tp))
+	_ = newTracingHook("redis-hook", WithTracerProvider(tp.TracerProvider("redis-test")))
 
 	if !invoked {
 		t.Fatalf("did not call custom TraceProvider")
diff --git a/extra/redisotel/tracing.go b/extra/redisotel/tracing.go
index 0bbf692ad..3d5f3426c 100644
--- a/extra/redisotel/tracing.go
+++ b/extra/redisotel/tracing.go
@@ -5,11 +5,12 @@ import (
 	"fmt"
 	"net"
 	"runtime"
+	"strconv"
 	"strings"
 
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
-	semconv "go.opentelemetry.io/otel/semconv/v1.10.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
 	"go.opentelemetry.io/otel/trace"
 
 	"github.com/redis/go-redis/extra/rediscmd/v9"
@@ -25,6 +26,7 @@ func InstrumentTracing(rdb redis.UniversalClient, opts ...TracingOption) error {
 	case *redis.Client:
 		opt := rdb.Options()
 		connString := formatDBConnString(opt.Network, opt.Addr)
+		opts = addServerAttributes(opts, opt.Addr)
 		rdb.AddHook(newTracingHook(connString, opts...))
 		return nil
 	case *redis.ClusterClient:
@@ -32,6 +34,7 @@ func InstrumentTracing(rdb redis.UniversalClient, opts ...TracingOption) error {
 
 		rdb.OnNewNode(func(rdb *redis.Client) {
 			opt := rdb.Options()
+			opts = addServerAttributes(opts, opt.Addr)
 			connString := formatDBConnString(opt.Network, opt.Addr)
 			rdb.AddHook(newTracingHook(connString, opts...))
 		})
@@ -41,6 +44,7 @@ func InstrumentTracing(rdb redis.UniversalClient, opts ...TracingOption) error {
 
 		rdb.OnNewNode(func(rdb *redis.Client) {
 			opt := rdb.Options()
+			opts = addServerAttributes(opts, opt.Addr)
 			connString := formatDBConnString(opt.Network, opt.Addr)
 			rdb.AddHook(newTracingHook(connString, opts...))
 		})
@@ -72,7 +76,7 @@ func newTracingHook(connString string, opts ...TracingOption) *tracingHook {
 		)
 	}
 	if connString != "" {
-		conf.attrs = append(conf.attrs, semconv.DBConnectionStringKey.String(connString))
+		conf.attrs = append(conf.attrs, semconv.DBConnectionString(connString))
 	}
 
 	return &tracingHook{
@@ -87,10 +91,6 @@ func newTracingHook(connString string, opts ...TracingOption) *tracingHook {
 
 func (th *tracingHook) DialHook(hook redis.DialHook) redis.DialHook {
 	return func(ctx context.Context, network, addr string) (net.Conn, error) {
-		if !trace.SpanFromContext(ctx).IsRecording() {
-			return hook(ctx, network, addr)
-		}
-
 		ctx, span := th.conf.tracer.Start(ctx, "redis.dial", th.spanOpts...)
 		defer span.End()
 
@@ -105,22 +105,18 @@ func (th *tracingHook) DialHook(hook redis.DialHook) redis.DialHook {
 
 func (th *tracingHook) ProcessHook(hook redis.ProcessHook) redis.ProcessHook {
 	return func(ctx context.Context, cmd redis.Cmder) error {
-		if !trace.SpanFromContext(ctx).IsRecording() {
-			return hook(ctx, cmd)
-		}
-
 		fn, file, line := funcFileLine("github.com/redis/go-redis")
 
 		attrs := make([]attribute.KeyValue, 0, 8)
 		attrs = append(attrs,
-			semconv.CodeFunctionKey.String(fn),
-			semconv.CodeFilepathKey.String(file),
-			semconv.CodeLineNumberKey.Int(line),
+			semconv.CodeFunction(fn),
+			semconv.CodeFilepath(file),
+			semconv.CodeLineNumber(line),
 		)
 
 		if th.conf.dbStmtEnabled {
 			cmdString := rediscmd.CmdString(cmd)
-			attrs = append(attrs, semconv.DBStatementKey.String(cmdString))
+			attrs = append(attrs, semconv.DBStatement(cmdString))
 		}
 
 		opts := th.spanOpts
@@ -141,23 +137,19 @@ func (th *tracingHook) ProcessPipelineHook(
 	hook redis.ProcessPipelineHook,
 ) redis.ProcessPipelineHook {
 	return func(ctx context.Context, cmds []redis.Cmder) error {
-		if !trace.SpanFromContext(ctx).IsRecording() {
-			return hook(ctx, cmds)
-		}
-
 		fn, file, line := funcFileLine("github.com/redis/go-redis")
 
 		attrs := make([]attribute.KeyValue, 0, 8)
 		attrs = append(attrs,
-			semconv.CodeFunctionKey.String(fn),
-			semconv.CodeFilepathKey.String(file),
-			semconv.CodeLineNumberKey.Int(line),
+			semconv.CodeFunction(fn),
+			semconv.CodeFilepath(file),
+			semconv.CodeLineNumber(line),
 			attribute.Int("db.redis.num_cmd", len(cmds)),
 		)
 
 		summary, cmdsString := rediscmd.CmdsString(cmds)
 		if th.conf.dbStmtEnabled {
-			attrs = append(attrs, semconv.DBStatementKey.String(cmdsString))
+			attrs = append(attrs, semconv.DBStatement(cmdsString))
 		}
 
 		opts := th.spanOpts
@@ -213,3 +205,28 @@ func funcFileLine(pkg string) (string, string, int) {
 
 	return fn, file, line
 }
+
+// Database span attributes semantic conventions recommended server address and port
+// https://opentelemetry.io/docs/specs/semconv/database/database-spans/#connection-level-attributes
+func addServerAttributes(opts []TracingOption, addr string) []TracingOption {
+	host, portString, err := net.SplitHostPort(addr)
+	if err != nil {
+		return opts
+	}
+
+	opts = append(opts, WithAttributes(
+		semconv.ServerAddress(host),
+	))
+
+	// Parse the port string to an integer
+	port, err := strconv.Atoi(portString)
+	if err != nil {
+		return opts
+	}
+
+	opts = append(opts, WithAttributes(
+		semconv.ServerPort(port),
+	))
+
+	return opts
+}
diff --git a/extra/redisprometheus/collector.go b/extra/redisprometheus/collector.go
index b726ec43a..77c424e89 100644
--- a/extra/redisprometheus/collector.go
+++ b/extra/redisprometheus/collector.go
@@ -29,12 +29,12 @@ var _ prometheus.Collector = (*Collector)(nil)
 // The given namespace and subsystem are used to build the fully qualified metric name,
 // i.e. "{namespace}_{subsystem}_{metric}".
 // The provided metrics are:
-//   * pool_hit_total
-//   * pool_miss_total
-//   * pool_timeout_total
-//   * pool_conn_total_current
-//   * pool_conn_idle_current
-//   * pool_conn_stale_total
+//   - pool_hit_total
+//   - pool_miss_total
+//   - pool_timeout_total
+//   - pool_conn_total_current
+//   - pool_conn_idle_current
+//   - pool_conn_stale_total
 func NewCollector(namespace, subsystem string, getter StatGetter) *Collector {
 	return &Collector{
 		getter: getter,
diff --git a/extra/redisprometheus/go.mod b/extra/redisprometheus/go.mod
index 9788fa373..fcc35b9bd 100644
--- a/extra/redisprometheus/go.mod
+++ b/extra/redisprometheus/go.mod
@@ -1,12 +1,12 @@
 module github.com/redis/go-redis/extra/redisprometheus/v9
 
-go 1.17
+go 1.19
 
 replace github.com/redis/go-redis/v9 => ../..
 
 require (
 	github.com/prometheus/client_golang v1.14.0
-	github.com/redis/go-redis/v9 v9.0.5
+	github.com/redis/go-redis/v9 v9.5.3
 )
 
 require (
@@ -19,5 +19,5 @@ require (
 	github.com/prometheus/common v0.39.0 // indirect
 	github.com/prometheus/procfs v0.9.0 // indirect
 	golang.org/x/sys v0.4.0 // indirect
-	google.golang.org/protobuf v1.28.1 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 )
diff --git a/extra/redisprometheus/go.sum b/extra/redisprometheus/go.sum
index 7cabce298..6528a5e33 100644
--- a/extra/redisprometheus/go.sum
+++ b/extra/redisprometheus/go.sum
@@ -1,7 +1,7 @@
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/bsm/ginkgo/v2 v2.7.0 h1:ItPMPH90RbmZJt5GtkcNvIRuGEdwlBItdNVoyzaNQao=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
+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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
@@ -29,5 +29,5 @@ golang.org/x/sys v0.4.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.28.1 h1:d0NfwRgPtno5B1Wa6L2DAG+KivqkdutMf1UhdNx175w=
-google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
diff --git a/gears_commands.go b/gears_commands.go
new file mode 100644
index 000000000..e0d49a6b7
--- /dev/null
+++ b/gears_commands.go
@@ -0,0 +1,149 @@
+package redis
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+type GearsCmdable interface {
+	TFunctionLoad(ctx context.Context, lib string) *StatusCmd
+	TFunctionLoadArgs(ctx context.Context, lib string, options *TFunctionLoadOptions) *StatusCmd
+	TFunctionDelete(ctx context.Context, libName string) *StatusCmd
+	TFunctionList(ctx context.Context) *MapStringInterfaceSliceCmd
+	TFunctionListArgs(ctx context.Context, options *TFunctionListOptions) *MapStringInterfaceSliceCmd
+	TFCall(ctx context.Context, libName string, funcName string, numKeys int) *Cmd
+	TFCallArgs(ctx context.Context, libName string, funcName string, numKeys int, options *TFCallOptions) *Cmd
+	TFCallASYNC(ctx context.Context, libName string, funcName string, numKeys int) *Cmd
+	TFCallASYNCArgs(ctx context.Context, libName string, funcName string, numKeys int, options *TFCallOptions) *Cmd
+}
+
+type TFunctionLoadOptions struct {
+	Replace bool
+	Config  string
+}
+
+type TFunctionListOptions struct {
+	Withcode bool
+	Verbose  int
+	Library  string
+}
+
+type TFCallOptions struct {
+	Keys      []string
+	Arguments []string
+}
+
+// TFunctionLoad - load a new JavaScript library into Redis.
+// For more information - https://redis.io/commands/tfunction-load/
+func (c cmdable) TFunctionLoad(ctx context.Context, lib string) *StatusCmd {
+	args := []interface{}{"TFUNCTION", "LOAD", lib}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) TFunctionLoadArgs(ctx context.Context, lib string, options *TFunctionLoadOptions) *StatusCmd {
+	args := []interface{}{"TFUNCTION", "LOAD"}
+	if options != nil {
+		if options.Replace {
+			args = append(args, "REPLACE")
+		}
+		if options.Config != "" {
+			args = append(args, "CONFIG", options.Config)
+		}
+	}
+	args = append(args, lib)
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TFunctionDelete - delete a JavaScript library from Redis.
+// For more information - https://redis.io/commands/tfunction-delete/
+func (c cmdable) TFunctionDelete(ctx context.Context, libName string) *StatusCmd {
+	args := []interface{}{"TFUNCTION", "DELETE", libName}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TFunctionList - list the functions with additional information about each function.
+// For more information - https://redis.io/commands/tfunction-list/
+func (c cmdable) TFunctionList(ctx context.Context) *MapStringInterfaceSliceCmd {
+	args := []interface{}{"TFUNCTION", "LIST"}
+	cmd := NewMapStringInterfaceSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) TFunctionListArgs(ctx context.Context, options *TFunctionListOptions) *MapStringInterfaceSliceCmd {
+	args := []interface{}{"TFUNCTION", "LIST"}
+	if options != nil {
+		if options.Withcode {
+			args = append(args, "WITHCODE")
+		}
+		if options.Verbose != 0 {
+			v := strings.Repeat("v", options.Verbose)
+			args = append(args, v)
+		}
+		if options.Library != "" {
+			args = append(args, "LIBRARY", options.Library)
+		}
+	}
+	cmd := NewMapStringInterfaceSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TFCall - invoke a function.
+// For more information - https://redis.io/commands/tfcall/
+func (c cmdable) TFCall(ctx context.Context, libName string, funcName string, numKeys int) *Cmd {
+	lf := libName + "." + funcName
+	args := []interface{}{"TFCALL", lf, numKeys}
+	cmd := NewCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) TFCallArgs(ctx context.Context, libName string, funcName string, numKeys int, options *TFCallOptions) *Cmd {
+	lf := libName + "." + funcName
+	args := []interface{}{"TFCALL", lf, numKeys}
+	if options != nil {
+		for _, key := range options.Keys {
+			args = append(args, key)
+		}
+		for _, key := range options.Arguments {
+			args = append(args, key)
+		}
+	}
+	cmd := NewCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TFCallASYNC - invoke an asynchronous JavaScript function (coroutine).
+// For more information - https://redis.io/commands/TFCallASYNC/
+func (c cmdable) TFCallASYNC(ctx context.Context, libName string, funcName string, numKeys int) *Cmd {
+	lf := fmt.Sprintf("%s.%s", libName, funcName)
+	args := []interface{}{"TFCALLASYNC", lf, numKeys}
+	cmd := NewCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) TFCallASYNCArgs(ctx context.Context, libName string, funcName string, numKeys int, options *TFCallOptions) *Cmd {
+	lf := fmt.Sprintf("%s.%s", libName, funcName)
+	args := []interface{}{"TFCALLASYNC", lf, numKeys}
+	if options != nil {
+		for _, key := range options.Keys {
+			args = append(args, key)
+		}
+		for _, key := range options.Arguments {
+			args = append(args, key)
+		}
+	}
+	cmd := NewCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/gears_commands_test.go b/gears_commands_test.go
new file mode 100644
index 000000000..b1117a4dc
--- /dev/null
+++ b/gears_commands_test.go
@@ -0,0 +1,114 @@
+package redis_test
+
+import (
+	"context"
+	"fmt"
+
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+
+	"github.com/redis/go-redis/v9"
+)
+
+func libCode(libName string) string {
+	return fmt.Sprintf("#!js api_version=1.0 name=%s\n redis.registerFunction('foo', ()=>{{return 'bar'}})", libName)
+}
+
+func libCodeWithConfig(libName string) string {
+	lib := `#!js api_version=1.0 name=%s
+
+	var last_update_field_name = "__last_update__"
+	
+	if (redis.config.last_update_field_name !== undefined) {
+		if (typeof redis.config.last_update_field_name != 'string') {
+			throw "last_update_field_name must be a string";
+		}
+		last_update_field_name = redis.config.last_update_field_name
+	}
+	
+	redis.registerFunction("hset", function(client, key, field, val){
+		// get the current time in ms
+		var curr_time = client.call("time")[0];
+		return client.call('hset', key, field, val, last_update_field_name, curr_time);
+	});`
+	return fmt.Sprintf(lib, libName)
+}
+
+var _ = Describe("RedisGears commands", Label("gears"), func() {
+	ctx := context.TODO()
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(&redis.Options{Addr: ":6379"})
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+		client.TFunctionDelete(ctx, "lib1")
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should TFunctionLoad, TFunctionLoadArgs and TFunctionDelete ", Label("gears", "tfunctionload"), func() {
+		resultAdd, err := client.TFunctionLoad(ctx, libCode("lib1")).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+		opt := &redis.TFunctionLoadOptions{Replace: true, Config: `{"last_update_field_name":"last_update"}`}
+		resultAdd, err = client.TFunctionLoadArgs(ctx, libCodeWithConfig("lib1"), opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+	})
+	It("should TFunctionList", Label("gears", "tfunctionlist"), func() {
+		resultAdd, err := client.TFunctionLoad(ctx, libCode("lib1")).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+		resultList, err := client.TFunctionList(ctx).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultList[0]["engine"]).To(BeEquivalentTo("js"))
+		opt := &redis.TFunctionListOptions{Withcode: true, Verbose: 2}
+		resultListArgs, err := client.TFunctionListArgs(ctx, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultListArgs[0]["code"]).NotTo(BeEquivalentTo(""))
+	})
+
+	It("should TFCall", Label("gears", "tfcall"), func() {
+		var resultAdd interface{}
+		resultAdd, err := client.TFunctionLoad(ctx, libCode("lib1")).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+		resultAdd, err = client.TFCall(ctx, "lib1", "foo", 0).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("bar"))
+	})
+
+	It("should TFCallArgs", Label("gears", "tfcallargs"), func() {
+		var resultAdd interface{}
+		resultAdd, err := client.TFunctionLoad(ctx, libCode("lib1")).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+		opt := &redis.TFCallOptions{Arguments: []string{"foo", "bar"}}
+		resultAdd, err = client.TFCallArgs(ctx, "lib1", "foo", 0, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("bar"))
+	})
+
+	It("should TFCallASYNC", Label("gears", "TFCallASYNC"), func() {
+		var resultAdd interface{}
+		resultAdd, err := client.TFunctionLoad(ctx, libCode("lib1")).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+		resultAdd, err = client.TFCallASYNC(ctx, "lib1", "foo", 0).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("bar"))
+	})
+
+	It("should TFCallASYNCArgs", Label("gears", "TFCallASYNCargs"), func() {
+		var resultAdd interface{}
+		resultAdd, err := client.TFunctionLoad(ctx, libCode("lib1")).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("OK"))
+		opt := &redis.TFCallOptions{Arguments: []string{"foo", "bar"}}
+		resultAdd, err = client.TFCallASYNCArgs(ctx, "lib1", "foo", 0, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo("bar"))
+	})
+})
diff --git a/generic_commands.go b/generic_commands.go
new file mode 100644
index 000000000..dc6c3fe01
--- /dev/null
+++ b/generic_commands.go
@@ -0,0 +1,384 @@
+package redis
+
+import (
+	"context"
+	"time"
+)
+
+type GenericCmdable interface {
+	Del(ctx context.Context, keys ...string) *IntCmd
+	Dump(ctx context.Context, key string) *StringCmd
+	Exists(ctx context.Context, keys ...string) *IntCmd
+	Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
+	ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
+	ExpireTime(ctx context.Context, key string) *DurationCmd
+	ExpireNX(ctx context.Context, key string, expiration time.Duration) *BoolCmd
+	ExpireXX(ctx context.Context, key string, expiration time.Duration) *BoolCmd
+	ExpireGT(ctx context.Context, key string, expiration time.Duration) *BoolCmd
+	ExpireLT(ctx context.Context, key string, expiration time.Duration) *BoolCmd
+	Keys(ctx context.Context, pattern string) *StringSliceCmd
+	Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd
+	Move(ctx context.Context, key string, db int) *BoolCmd
+	ObjectFreq(ctx context.Context, key string) *IntCmd
+	ObjectRefCount(ctx context.Context, key string) *IntCmd
+	ObjectEncoding(ctx context.Context, key string) *StringCmd
+	ObjectIdleTime(ctx context.Context, key string) *DurationCmd
+	Persist(ctx context.Context, key string) *BoolCmd
+	PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd
+	PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd
+	PExpireTime(ctx context.Context, key string) *DurationCmd
+	PTTL(ctx context.Context, key string) *DurationCmd
+	RandomKey(ctx context.Context) *StringCmd
+	Rename(ctx context.Context, key, newkey string) *StatusCmd
+	RenameNX(ctx context.Context, key, newkey string) *BoolCmd
+	Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
+	RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd
+	Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd
+	SortRO(ctx context.Context, key string, sort *Sort) *StringSliceCmd
+	SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd
+	SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd
+	Touch(ctx context.Context, keys ...string) *IntCmd
+	TTL(ctx context.Context, key string) *DurationCmd
+	Type(ctx context.Context, key string) *StatusCmd
+	Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *IntCmd
+
+	Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd
+	ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd
+}
+
+func (c cmdable) Del(ctx context.Context, keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "del"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Unlink(ctx context.Context, keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "unlink"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Dump(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "dump", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Exists(ctx context.Context, keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "exists"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Expire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
+	return c.expire(ctx, key, expiration, "")
+}
+
+func (c cmdable) ExpireNX(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
+	return c.expire(ctx, key, expiration, "NX")
+}
+
+func (c cmdable) ExpireXX(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
+	return c.expire(ctx, key, expiration, "XX")
+}
+
+func (c cmdable) ExpireGT(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
+	return c.expire(ctx, key, expiration, "GT")
+}
+
+func (c cmdable) ExpireLT(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
+	return c.expire(ctx, key, expiration, "LT")
+}
+
+func (c cmdable) expire(
+	ctx context.Context, key string, expiration time.Duration, mode string,
+) *BoolCmd {
+	args := make([]interface{}, 3, 4)
+	args[0] = "expire"
+	args[1] = key
+	args[2] = formatSec(ctx, expiration)
+	if mode != "" {
+		args = append(args, mode)
+	}
+
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "expireat", key, tm.Unix())
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ExpireTime(ctx context.Context, key string) *DurationCmd {
+	cmd := NewDurationCmd(ctx, time.Second, "expiretime", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Keys(ctx context.Context, pattern string) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "keys", pattern)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Migrate(ctx context.Context, host, port, key string, db int, timeout time.Duration) *StatusCmd {
+	cmd := NewStatusCmd(
+		ctx,
+		"migrate",
+		host,
+		port,
+		key,
+		db,
+		formatMs(ctx, timeout),
+	)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Move(ctx context.Context, key string, db int) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "move", key, db)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ObjectFreq(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "object", "freq", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ObjectRefCount(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "object", "refcount", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ObjectEncoding(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "object", "encoding", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ObjectIdleTime(ctx context.Context, key string) *DurationCmd {
+	cmd := NewDurationCmd(ctx, time.Second, "object", "idletime", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Persist(ctx context.Context, key string) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "persist", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PExpire(ctx context.Context, key string, expiration time.Duration) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "pexpire", key, formatMs(ctx, expiration))
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PExpireAt(ctx context.Context, key string, tm time.Time) *BoolCmd {
+	cmd := NewBoolCmd(
+		ctx,
+		"pexpireat",
+		key,
+		tm.UnixNano()/int64(time.Millisecond),
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PExpireTime(ctx context.Context, key string) *DurationCmd {
+	cmd := NewDurationCmd(ctx, time.Millisecond, "pexpiretime", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PTTL(ctx context.Context, key string) *DurationCmd {
+	cmd := NewDurationCmd(ctx, time.Millisecond, "pttl", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RandomKey(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "randomkey")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Rename(ctx context.Context, key, newkey string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "rename", key, newkey)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RenameNX(ctx context.Context, key, newkey string) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "renamenx", key, newkey)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Restore(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
+	cmd := NewStatusCmd(
+		ctx,
+		"restore",
+		key,
+		formatMs(ctx, ttl),
+		value,
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *StatusCmd {
+	cmd := NewStatusCmd(
+		ctx,
+		"restore",
+		key,
+		formatMs(ctx, ttl),
+		value,
+		"replace",
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type Sort struct {
+	By            string
+	Offset, Count int64
+	Get           []string
+	Order         string
+	Alpha         bool
+}
+
+func (sort *Sort) args(command, key string) []interface{} {
+	args := []interface{}{command, key}
+
+	if sort.By != "" {
+		args = append(args, "by", sort.By)
+	}
+	if sort.Offset != 0 || sort.Count != 0 {
+		args = append(args, "limit", sort.Offset, sort.Count)
+	}
+	for _, get := range sort.Get {
+		args = append(args, "get", get)
+	}
+	if sort.Order != "" {
+		args = append(args, sort.Order)
+	}
+	if sort.Alpha {
+		args = append(args, "alpha")
+	}
+	return args
+}
+
+func (c cmdable) SortRO(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, sort.args("sort_ro", key)...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Sort(ctx context.Context, key string, sort *Sort) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, sort.args("sort", key)...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SortStore(ctx context.Context, key, store string, sort *Sort) *IntCmd {
+	args := sort.args("sort", key)
+	if store != "" {
+		args = append(args, "store", store)
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SortInterfaces(ctx context.Context, key string, sort *Sort) *SliceCmd {
+	cmd := NewSliceCmd(ctx, sort.args("sort", key)...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Touch(ctx context.Context, keys ...string) *IntCmd {
+	args := make([]interface{}, len(keys)+1)
+	args[0] = "touch"
+	for i, key := range keys {
+		args[i+1] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) TTL(ctx context.Context, key string) *DurationCmd {
+	cmd := NewDurationCmd(ctx, time.Second, "ttl", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Type(ctx context.Context, key string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "type", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Copy(ctx context.Context, sourceKey, destKey string, db int, replace bool) *IntCmd {
+	args := []interface{}{"copy", sourceKey, destKey, "DB", db}
+	if replace {
+		args = append(args, "REPLACE")
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c cmdable) Scan(ctx context.Context, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"scan", cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(ctx, c, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *ScanCmd {
+	args := []interface{}{"scan", cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	if keyType != "" {
+		args = append(args, "type", keyType)
+	}
+	cmd := NewScanCmd(ctx, c, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/geo_commands.go b/geo_commands.go
new file mode 100644
index 000000000..f047b98aa
--- /dev/null
+++ b/geo_commands.go
@@ -0,0 +1,155 @@
+package redis
+
+import (
+	"context"
+	"errors"
+)
+
+type GeoCmdable interface {
+	GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd
+	GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd
+	GeoRadius(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd
+	GeoRadiusStore(ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery) *IntCmd
+	GeoRadiusByMember(ctx context.Context, key, member string, query *GeoRadiusQuery) *GeoLocationCmd
+	GeoRadiusByMemberStore(ctx context.Context, key, member string, query *GeoRadiusQuery) *IntCmd
+	GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd
+	GeoSearchLocation(ctx context.Context, key string, q *GeoSearchLocationQuery) *GeoSearchLocationCmd
+	GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd
+	GeoDist(ctx context.Context, key string, member1, member2, unit string) *FloatCmd
+	GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd
+}
+
+func (c cmdable) GeoAdd(ctx context.Context, key string, geoLocation ...*GeoLocation) *IntCmd {
+	args := make([]interface{}, 2+3*len(geoLocation))
+	args[0] = "geoadd"
+	args[1] = key
+	for i, eachLoc := range geoLocation {
+		args[2+3*i] = eachLoc.Longitude
+		args[2+3*i+1] = eachLoc.Latitude
+		args[2+3*i+2] = eachLoc.Name
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// GeoRadius is a read-only GEORADIUS_RO command.
+func (c cmdable) GeoRadius(
+	ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,
+) *GeoLocationCmd {
+	cmd := NewGeoLocationCmd(ctx, query, "georadius_ro", key, longitude, latitude)
+	if query.Store != "" || query.StoreDist != "" {
+		cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))
+		return cmd
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// GeoRadiusStore is a writing GEORADIUS command.
+func (c cmdable) GeoRadiusStore(
+	ctx context.Context, key string, longitude, latitude float64, query *GeoRadiusQuery,
+) *IntCmd {
+	args := geoLocationArgs(query, "georadius", key, longitude, latitude)
+	cmd := NewIntCmd(ctx, args...)
+	if query.Store == "" && query.StoreDist == "" {
+		cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
+		return cmd
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// GeoRadiusByMember is a read-only GEORADIUSBYMEMBER_RO command.
+func (c cmdable) GeoRadiusByMember(
+	ctx context.Context, key, member string, query *GeoRadiusQuery,
+) *GeoLocationCmd {
+	cmd := NewGeoLocationCmd(ctx, query, "georadiusbymember_ro", key, member)
+	if query.Store != "" || query.StoreDist != "" {
+		cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
+		return cmd
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// GeoRadiusByMemberStore is a writing GEORADIUSBYMEMBER command.
+func (c cmdable) GeoRadiusByMemberStore(
+	ctx context.Context, key, member string, query *GeoRadiusQuery,
+) *IntCmd {
+	args := geoLocationArgs(query, "georadiusbymember", key, member)
+	cmd := NewIntCmd(ctx, args...)
+	if query.Store == "" && query.StoreDist == "" {
+		cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
+		return cmd
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GeoSearch(ctx context.Context, key string, q *GeoSearchQuery) *StringSliceCmd {
+	args := make([]interface{}, 0, 13)
+	args = append(args, "geosearch", key)
+	args = geoSearchArgs(q, args)
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GeoSearchLocation(
+	ctx context.Context, key string, q *GeoSearchLocationQuery,
+) *GeoSearchLocationCmd {
+	args := make([]interface{}, 0, 16)
+	args = append(args, "geosearch", key)
+	args = geoSearchLocationArgs(q, args)
+	cmd := NewGeoSearchLocationCmd(ctx, q, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GeoSearchStore(ctx context.Context, key, store string, q *GeoSearchStoreQuery) *IntCmd {
+	args := make([]interface{}, 0, 15)
+	args = append(args, "geosearchstore", store, key)
+	args = geoSearchArgs(&q.GeoSearchQuery, args)
+	if q.StoreDist {
+		args = append(args, "storedist")
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GeoDist(
+	ctx context.Context, key string, member1, member2, unit string,
+) *FloatCmd {
+	if unit == "" {
+		unit = "km"
+	}
+	cmd := NewFloatCmd(ctx, "geodist", key, member1, member2, unit)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GeoHash(ctx context.Context, key string, members ...string) *StringSliceCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "geohash"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GeoPos(ctx context.Context, key string, members ...string) *GeoPosCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "geopos"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewGeoPosCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/go.mod b/go.mod
index c13deb880..6c65f094f 100644
--- a/go.mod
+++ b/go.mod
@@ -3,8 +3,8 @@ module github.com/redis/go-redis/v9
 go 1.18
 
 require (
-	github.com/bsm/ginkgo/v2 v2.9.5
-	github.com/bsm/gomega v1.26.0
+	github.com/bsm/ginkgo/v2 v2.12.0
+	github.com/bsm/gomega v1.27.10
 	github.com/cespare/xxhash/v2 v2.2.0
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f
 )
diff --git a/go.sum b/go.sum
index be26cfe3e..21b4f64ee 100644
--- a/go.sum
+++ b/go.sum
@@ -1,7 +1,7 @@
-github.com/bsm/ginkgo/v2 v2.9.5 h1:rtVBYPs3+TC5iLUVOis1B9tjLTup7Cj5IfzosKtvTJ0=
-github.com/bsm/ginkgo/v2 v2.9.5/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
-github.com/bsm/gomega v1.26.0 h1:LhQm+AFcgV2M0WyKroMASzAzCAJVpAxQXv4SaI9a69Y=
-github.com/bsm/gomega v1.26.0/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
+github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
+github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
+github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
+github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
 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/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
diff --git a/hash_commands.go b/hash_commands.go
new file mode 100644
index 000000000..2c62a75ad
--- /dev/null
+++ b/hash_commands.go
@@ -0,0 +1,174 @@
+package redis
+
+import "context"
+
+type HashCmdable interface {
+	HDel(ctx context.Context, key string, fields ...string) *IntCmd
+	HExists(ctx context.Context, key, field string) *BoolCmd
+	HGet(ctx context.Context, key, field string) *StringCmd
+	HGetAll(ctx context.Context, key string) *MapStringStringCmd
+	HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd
+	HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd
+	HKeys(ctx context.Context, key string) *StringSliceCmd
+	HLen(ctx context.Context, key string) *IntCmd
+	HMGet(ctx context.Context, key string, fields ...string) *SliceCmd
+	HSet(ctx context.Context, key string, values ...interface{}) *IntCmd
+	HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd
+	HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd
+	HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
+	HVals(ctx context.Context, key string) *StringSliceCmd
+	HRandField(ctx context.Context, key string, count int) *StringSliceCmd
+	HRandFieldWithValues(ctx context.Context, key string, count int) *KeyValueSliceCmd
+}
+
+func (c cmdable) HDel(ctx context.Context, key string, fields ...string) *IntCmd {
+	args := make([]interface{}, 2+len(fields))
+	args[0] = "hdel"
+	args[1] = key
+	for i, field := range fields {
+		args[2+i] = field
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HExists(ctx context.Context, key, field string) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "hexists", key, field)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HGet(ctx context.Context, key, field string) *StringCmd {
+	cmd := NewStringCmd(ctx, "hget", key, field)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HGetAll(ctx context.Context, key string) *MapStringStringCmd {
+	cmd := NewMapStringStringCmd(ctx, "hgetall", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HIncrBy(ctx context.Context, key, field string, incr int64) *IntCmd {
+	cmd := NewIntCmd(ctx, "hincrby", key, field, incr)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HIncrByFloat(ctx context.Context, key, field string, incr float64) *FloatCmd {
+	cmd := NewFloatCmd(ctx, "hincrbyfloat", key, field, incr)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HKeys(ctx context.Context, key string) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "hkeys", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HLen(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "hlen", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// HMGet returns the values for the specified fields in the hash stored at key.
+// It returns an interface{} to distinguish between empty string and nil value.
+func (c cmdable) HMGet(ctx context.Context, key string, fields ...string) *SliceCmd {
+	args := make([]interface{}, 2+len(fields))
+	args[0] = "hmget"
+	args[1] = key
+	for i, field := range fields {
+		args[2+i] = field
+	}
+	cmd := NewSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// HSet accepts values in following formats:
+//
+//   - HSet("myhash", "key1", "value1", "key2", "value2")
+//
+//   - HSet("myhash", []string{"key1", "value1", "key2", "value2"})
+//
+//   - HSet("myhash", map[string]interface{}{"key1": "value1", "key2": "value2"})
+//
+//     Playing struct With "redis" tag.
+//     type MyHash struct { Key1 string `redis:"key1"`; Key2 int `redis:"key2"` }
+//
+//   - HSet("myhash", MyHash{"value1", "value2"}) Warn: redis-server >= 4.0
+//
+//     For struct, can be a structure pointer type, we only parse the field whose tag is redis.
+//     if you don't want the field to be read, you can use the `redis:"-"` flag to ignore it,
+//     or you don't need to set the redis tag.
+//     For the type of structure field, we only support simple data types:
+//     string, int/uint(8,16,32,64), float(32,64), time.Time(to RFC3339Nano), time.Duration(to Nanoseconds ),
+//     if you are other more complex or custom data types, please implement the encoding.BinaryMarshaler interface.
+//
+// Note that in older versions of Redis server(redis-server < 4.0), HSet only supports a single key-value pair.
+// redis-docs: https://redis.io/commands/hset (Starting with Redis version 4.0.0: Accepts multiple field and value arguments.)
+// If you are using a Struct type and the number of fields is greater than one,
+// you will receive an error similar to "ERR wrong number of arguments", you can use HMSet as a substitute.
+func (c cmdable) HSet(ctx context.Context, key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "hset"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// HMSet is a deprecated version of HSet left for compatibility with Redis 3.
+func (c cmdable) HMSet(ctx context.Context, key string, values ...interface{}) *BoolCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "hmset"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HSetNX(ctx context.Context, key, field string, value interface{}) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "hsetnx", key, field, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HVals(ctx context.Context, key string) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "hvals", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// HRandField redis-server version >= 6.2.0.
+func (c cmdable) HRandField(ctx context.Context, key string, count int) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "hrandfield", key, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// HRandFieldWithValues redis-server version >= 6.2.0.
+func (c cmdable) HRandFieldWithValues(ctx context.Context, key string, count int) *KeyValueSliceCmd {
+	cmd := NewKeyValueSliceCmd(ctx, "hrandfield", key, count, "withvalues")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"hscan", key, cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(ctx, c, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/hyperloglog_commands.go b/hyperloglog_commands.go
new file mode 100644
index 000000000..5a608fae2
--- /dev/null
+++ b/hyperloglog_commands.go
@@ -0,0 +1,42 @@
+package redis
+
+import "context"
+
+type HyperLogLogCmdable interface {
+	PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd
+	PFCount(ctx context.Context, keys ...string) *IntCmd
+	PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd
+}
+
+func (c cmdable) PFAdd(ctx context.Context, key string, els ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(els))
+	args[0] = "pfadd"
+	args[1] = key
+	args = appendArgs(args, els)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PFCount(ctx context.Context, keys ...string) *IntCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "pfcount"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PFMerge(ctx context.Context, dest string, keys ...string) *StatusCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "pfmerge"
+	args[1] = dest
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/internal/customvet/checks/setval/setval.go b/internal/customvet/checks/setval/setval.go
index e629f5f7a..924a9bfc8 100644
--- a/internal/customvet/checks/setval/setval.go
+++ b/internal/customvet/checks/setval/setval.go
@@ -4,6 +4,7 @@ import (
 	"go/ast"
 	"go/token"
 	"go/types"
+
 	"golang.org/x/tools/go/analysis"
 )
 
diff --git a/internal/customvet/checks/setval/setval_test.go b/internal/customvet/checks/setval/setval_test.go
index e75647a3d..d93ec45fe 100644
--- a/internal/customvet/checks/setval/setval_test.go
+++ b/internal/customvet/checks/setval/setval_test.go
@@ -3,8 +3,9 @@ package setval_test
 import (
 	"testing"
 
-	"github.com/redis/go-redis/internal/customvet/checks/setval"
 	"golang.org/x/tools/go/analysis/analysistest"
+
+	"github.com/redis/go-redis/internal/customvet/checks/setval"
 )
 
 func Test(t *testing.T) {
diff --git a/internal/customvet/main.go b/internal/customvet/main.go
index a97a49c9d..6a06ee217 100644
--- a/internal/customvet/main.go
+++ b/internal/customvet/main.go
@@ -1,8 +1,9 @@
 package main
 
 import (
-	"github.com/redis/go-redis/internal/customvet/checks/setval"
 	"golang.org/x/tools/go/analysis/multichecker"
+
+	"github.com/redis/go-redis/internal/customvet/checks/setval"
 )
 
 func main() {
diff --git a/internal/hscan/hscan_test.go b/internal/hscan/hscan_test.go
index 728ffad0a..6c9b30306 100644
--- a/internal/hscan/hscan_test.go
+++ b/internal/hscan/hscan_test.go
@@ -8,6 +8,8 @@ import (
 
 	. "github.com/bsm/ginkgo/v2"
 	. "github.com/bsm/gomega"
+
+	"github.com/redis/go-redis/v9/internal/util"
 )
 
 type data struct {
@@ -29,6 +31,7 @@ type data struct {
 	Float   float32 `redis:"float"`
 	Float64 float64 `redis:"float64"`
 	Bool    bool    `redis:"bool"`
+	BoolRef *bool   `redis:"boolRef"`
 }
 
 type TimeRFC3339Nano struct {
@@ -117,10 +120,10 @@ var _ = Describe("Scan", func() {
 		Expect(Scan(&d, i{"key"}, i{"value"})).NotTo(HaveOccurred())
 		Expect(d).To(Equal(data{}))
 
-		keys := i{"string", "byte", "int", "int64", "uint", "uint64", "float", "float64", "bool"}
+		keys := i{"string", "byte", "int", "int64", "uint", "uint64", "float", "float64", "bool", "boolRef"}
 		vals := i{
 			"str!", "bytes!", "123", "123456789123456789", "456", "987654321987654321",
-			"123.456", "123456789123456789.987654321987654321", "1",
+			"123.456", "123456789123456789.987654321987654321", "1", "1",
 		}
 		Expect(Scan(&d, keys, vals)).NotTo(HaveOccurred())
 		Expect(d).To(Equal(data{
@@ -133,6 +136,7 @@ var _ = Describe("Scan", func() {
 			Float:   123.456,
 			Float64: 1.2345678912345678e+17,
 			Bool:    true,
+			BoolRef: util.ToPtr(true),
 		}))
 
 		// Scan a different type with the same values to test that
@@ -167,6 +171,7 @@ var _ = Describe("Scan", func() {
 			Float:   1.0,
 			Float64: 1.2345678912345678e+17,
 			Bool:    true,
+			BoolRef: util.ToPtr(true),
 		}))
 	})
 
diff --git a/internal/hscan/structmap.go b/internal/hscan/structmap.go
index 234079f0b..1a560e4a3 100644
--- a/internal/hscan/structmap.go
+++ b/internal/hscan/structmap.go
@@ -61,7 +61,11 @@ func newStructSpec(t reflect.Type, fieldTag string) *structSpec {
 		}
 
 		// Use the built-in decoder.
-		out.set(tag, &structField{index: i, fn: decoders[f.Type.Kind()]})
+		kind := f.Type.Kind()
+		if kind == reflect.Pointer {
+			kind = f.Type.Elem().Kind()
+		}
+		out.set(tag, &structField{index: i, fn: decoders[kind]})
 	}
 
 	return out
diff --git a/internal/pool/conn_check.go b/internal/pool/conn_check.go
index f04dc1c3b..83190d394 100644
--- a/internal/pool/conn_check.go
+++ b/internal/pool/conn_check.go
@@ -1,5 +1,4 @@
 //go:build linux || darwin || dragonfly || freebsd || netbsd || openbsd || solaris || illumos
-// +build linux darwin dragonfly freebsd netbsd openbsd solaris illumos
 
 package pool
 
diff --git a/internal/pool/conn_check_dummy.go b/internal/pool/conn_check_dummy.go
index 9408446b5..295da1268 100644
--- a/internal/pool/conn_check_dummy.go
+++ b/internal/pool/conn_check_dummy.go
@@ -1,5 +1,4 @@
 //go:build !linux && !darwin && !dragonfly && !freebsd && !netbsd && !openbsd && !solaris && !illumos
-// +build !linux,!darwin,!dragonfly,!freebsd,!netbsd,!openbsd,!solaris,!illumos
 
 package pool
 
diff --git a/internal/pool/conn_check_test.go b/internal/pool/conn_check_test.go
index e5acb9f8f..2ade8a0b9 100644
--- a/internal/pool/conn_check_test.go
+++ b/internal/pool/conn_check_test.go
@@ -1,5 +1,4 @@
 //go:build linux || darwin || dragonfly || freebsd || netbsd || openbsd || solaris || illumos
-// +build linux darwin dragonfly freebsd netbsd openbsd solaris illumos
 
 package pool
 
diff --git a/internal/pool/pool.go b/internal/pool/pool.go
index bb9b14beb..2125f3e13 100644
--- a/internal/pool/pool.go
+++ b/internal/pool/pool.go
@@ -15,6 +15,10 @@ var (
 	// ErrClosed performs any operation on the closed client will return this error.
 	ErrClosed = errors.New("redis: client is closed")
 
+	// ErrPoolExhausted is returned from a pool connection method
+	// when the maximum number of database connections in the pool has been reached.
+	ErrPoolExhausted = errors.New("redis: connection pool exhausted")
+
 	// ErrPoolTimeout timed out waiting to get a connection from the connection pool.
 	ErrPoolTimeout = errors.New("redis: connection pool timeout")
 )
@@ -61,6 +65,7 @@ type Options struct {
 	PoolTimeout     time.Duration
 	MinIdleConns    int
 	MaxIdleConns    int
+	MaxActiveConns  int
 	ConnMaxIdleTime time.Duration
 	ConnMaxLifetime time.Duration
 }
@@ -159,6 +164,17 @@ func (p *ConnPool) NewConn(ctx context.Context) (*Conn, error) {
 }
 
 func (p *ConnPool) newConn(ctx context.Context, pooled bool) (*Conn, error) {
+	if p.closed() {
+		return nil, ErrClosed
+	}
+
+	p.connsMu.Lock()
+	if p.cfg.MaxActiveConns > 0 && p.poolSize >= p.cfg.MaxActiveConns {
+		p.connsMu.Unlock()
+		return nil, ErrPoolExhausted
+	}
+	p.connsMu.Unlock()
+
 	cn, err := p.dialConn(ctx, pooled)
 	if err != nil {
 		return nil, err
@@ -167,10 +183,9 @@ func (p *ConnPool) newConn(ctx context.Context, pooled bool) (*Conn, error) {
 	p.connsMu.Lock()
 	defer p.connsMu.Unlock()
 
-	// It is not allowed to add new connections to the closed connection pool.
-	if p.closed() {
+	if p.cfg.MaxActiveConns > 0 && p.poolSize >= p.cfg.MaxActiveConns {
 		_ = cn.Close()
-		return nil, ErrClosed
+		return nil, ErrPoolExhausted
 	}
 
 	p.conns = append(p.conns, cn)
@@ -256,6 +271,7 @@ func (p *ConnPool) Get(ctx context.Context) (*Conn, error) {
 		p.connsMu.Unlock()
 
 		if err != nil {
+			p.freeTurn()
 			return nil, err
 		}
 
diff --git a/internal/proto/writer.go b/internal/proto/writer.go
index 8eaada196..78595cc4f 100644
--- a/internal/proto/writer.go
+++ b/internal/proto/writer.go
@@ -65,37 +65,68 @@ func (w *Writer) WriteArg(v interface{}) error {
 		return w.string("")
 	case string:
 		return w.string(v)
+	case *string:
+		return w.string(*v)
 	case []byte:
 		return w.bytes(v)
 	case int:
 		return w.int(int64(v))
+	case *int:
+		return w.int(int64(*v))
 	case int8:
 		return w.int(int64(v))
+	case *int8:
+		return w.int(int64(*v))
 	case int16:
 		return w.int(int64(v))
+	case *int16:
+		return w.int(int64(*v))
 	case int32:
 		return w.int(int64(v))
+	case *int32:
+		return w.int(int64(*v))
 	case int64:
 		return w.int(v)
+	case *int64:
+		return w.int(*v)
 	case uint:
 		return w.uint(uint64(v))
+	case *uint:
+		return w.uint(uint64(*v))
 	case uint8:
 		return w.uint(uint64(v))
+	case *uint8:
+		return w.uint(uint64(*v))
 	case uint16:
 		return w.uint(uint64(v))
+	case *uint16:
+		return w.uint(uint64(*v))
 	case uint32:
 		return w.uint(uint64(v))
+	case *uint32:
+		return w.uint(uint64(*v))
 	case uint64:
 		return w.uint(v)
+	case *uint64:
+		return w.uint(*v)
 	case float32:
 		return w.float(float64(v))
+	case *float32:
+		return w.float(float64(*v))
 	case float64:
 		return w.float(v)
+	case *float64:
+		return w.float(*v)
 	case bool:
 		if v {
 			return w.int(1)
 		}
 		return w.int(0)
+	case *bool:
+		if *v {
+			return w.int(1)
+		}
+		return w.int(0)
 	case time.Time:
 		w.numBuf = v.AppendFormat(w.numBuf[:0], time.RFC3339Nano)
 		return w.bytes(w.numBuf)
diff --git a/internal/proto/writer_test.go b/internal/proto/writer_test.go
index c801f87db..7c9d20884 100644
--- a/internal/proto/writer_test.go
+++ b/internal/proto/writer_test.go
@@ -12,6 +12,7 @@ import (
 	. "github.com/bsm/gomega"
 
 	"github.com/redis/go-redis/v9/internal/proto"
+	"github.com/redis/go-redis/v9/internal/util"
 )
 
 type MyType struct{}
@@ -100,3 +101,54 @@ func BenchmarkWriteBuffer_Append(b *testing.B) {
 		}
 	}
 }
+
+var _ = Describe("WriteArg", func() {
+	var buf *bytes.Buffer
+	var wr *proto.Writer
+
+	BeforeEach(func() {
+		buf = new(bytes.Buffer)
+		wr = proto.NewWriter(buf)
+	})
+
+	args := map[any]string{
+		"hello":                   "$5\r\nhello\r\n",
+		int(10):                   "$2\r\n10\r\n",
+		util.ToPtr(int(10)):       "$2\r\n10\r\n",
+		int8(10):                  "$2\r\n10\r\n",
+		util.ToPtr(int8(10)):      "$2\r\n10\r\n",
+		int16(10):                 "$2\r\n10\r\n",
+		util.ToPtr(int16(10)):     "$2\r\n10\r\n",
+		int32(10):                 "$2\r\n10\r\n",
+		util.ToPtr(int32(10)):     "$2\r\n10\r\n",
+		int64(10):                 "$2\r\n10\r\n",
+		util.ToPtr(int64(10)):     "$2\r\n10\r\n",
+		uint(10):                  "$2\r\n10\r\n",
+		util.ToPtr(uint(10)):      "$2\r\n10\r\n",
+		uint8(10):                 "$2\r\n10\r\n",
+		util.ToPtr(uint8(10)):     "$2\r\n10\r\n",
+		uint16(10):                "$2\r\n10\r\n",
+		util.ToPtr(uint16(10)):    "$2\r\n10\r\n",
+		uint32(10):                "$2\r\n10\r\n",
+		util.ToPtr(uint32(10)):    "$2\r\n10\r\n",
+		uint64(10):                "$2\r\n10\r\n",
+		util.ToPtr(uint64(10)):    "$2\r\n10\r\n",
+		float32(10.3):             "$18\r\n10.300000190734863\r\n",
+		util.ToPtr(float32(10.3)): "$18\r\n10.300000190734863\r\n",
+		float64(10.3):             "$4\r\n10.3\r\n",
+		util.ToPtr(float64(10.3)): "$4\r\n10.3\r\n",
+		bool(true):                "$1\r\n1\r\n",
+		bool(false):               "$1\r\n0\r\n",
+		util.ToPtr(bool(true)):    "$1\r\n1\r\n",
+		util.ToPtr(bool(false)):   "$1\r\n0\r\n",
+	}
+
+	for arg, expect := range args {
+		arg, expect := arg, expect
+		It(fmt.Sprintf("should write arg of type %T", arg), func() {
+			err := wr.WriteArg(arg)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(buf.String()).To(Equal(expect))
+		})
+	}
+})
diff --git a/internal/util.go b/internal/util.go
index 77ca4ee11..235a91afa 100644
--- a/internal/util.go
+++ b/internal/util.go
@@ -2,6 +2,8 @@ package internal
 
 import (
 	"context"
+	"net"
+	"strings"
 	"time"
 
 	"github.com/redis/go-redis/v9/internal/util"
@@ -44,3 +46,38 @@ func isLower(s string) bool {
 	}
 	return true
 }
+
+func ReplaceSpaces(s string) string {
+	// Pre-allocate a builder with the same length as s to minimize allocations.
+	// This is a basic optimization; adjust the initial size based on your use case.
+	var builder strings.Builder
+	builder.Grow(len(s))
+
+	for _, char := range s {
+		if char == ' ' {
+			// Replace space with a hyphen.
+			builder.WriteRune('-')
+		} else {
+			// Copy the character as-is.
+			builder.WriteRune(char)
+		}
+	}
+
+	return builder.String()
+}
+
+func GetAddr(addr string) string {
+	ind := strings.LastIndexByte(addr, ':')
+	if ind == -1 {
+		return ""
+	}
+
+	if strings.IndexByte(addr, '.') != -1 {
+		return addr
+	}
+
+	if addr[0] == '[' {
+		return addr
+	}
+	return net.JoinHostPort(addr[:ind], addr[ind+1:])
+}
diff --git a/internal/util/safe.go b/internal/util/safe.go
index 21307110b..8178f86df 100644
--- a/internal/util/safe.go
+++ b/internal/util/safe.go
@@ -1,5 +1,4 @@
 //go:build appengine
-// +build appengine
 
 package util
 
diff --git a/internal/util/type.go b/internal/util/type.go
new file mode 100644
index 000000000..a7ea712ed
--- /dev/null
+++ b/internal/util/type.go
@@ -0,0 +1,5 @@
+package util
+
+func ToPtr[T any](v T) *T {
+	return &v
+}
diff --git a/internal/util/unsafe.go b/internal/util/unsafe.go
index daa8d7692..cbcd2cc09 100644
--- a/internal/util/unsafe.go
+++ b/internal/util/unsafe.go
@@ -1,5 +1,4 @@
 //go:build !appengine
-// +build !appengine
 
 package util
 
diff --git a/internal/util_test.go b/internal/util_test.go
new file mode 100644
index 000000000..57f7f9fa1
--- /dev/null
+++ b/internal/util_test.go
@@ -0,0 +1,74 @@
+package internal
+
+import (
+	"strings"
+	"testing"
+
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+)
+
+func BenchmarkToLowerStd(b *testing.B) {
+	str := "AaBbCcDdEeFfGgHhIiJjKk"
+	for i := 0; i < b.N; i++ {
+		_ = strings.ToLower(str)
+	}
+}
+
+// util.ToLower is 3x faster than strings.ToLower.
+func BenchmarkToLowerInternal(b *testing.B) {
+	str := "AaBbCcDdEeFfGgHhIiJjKk"
+	for i := 0; i < b.N; i++ {
+		_ = ToLower(str)
+	}
+}
+
+func TestToLower(t *testing.T) {
+	It("toLower", func() {
+		str := "AaBbCcDdEeFfGg"
+		Expect(ToLower(str)).To(Equal(strings.ToLower(str)))
+
+		str = "ABCDE"
+		Expect(ToLower(str)).To(Equal(strings.ToLower(str)))
+
+		str = "ABCDE"
+		Expect(ToLower(str)).To(Equal(strings.ToLower(str)))
+
+		str = "abced"
+		Expect(ToLower(str)).To(Equal(strings.ToLower(str)))
+	})
+}
+
+func TestIsLower(t *testing.T) {
+	It("isLower", func() {
+		str := "AaBbCcDdEeFfGg"
+		Expect(isLower(str)).To(BeFalse())
+
+		str = "ABCDE"
+		Expect(isLower(str)).To(BeFalse())
+
+		str = "abcdefg"
+		Expect(isLower(str)).To(BeTrue())
+	})
+}
+
+func TestGetAddr(t *testing.T) {
+	It("getAddr", func() {
+		str := "127.0.0.1:1234"
+		Expect(GetAddr(str)).To(Equal(str))
+
+		str = "[::1]:1234"
+		Expect(GetAddr(str)).To(Equal(str))
+
+		str = "[fd01:abcd::7d03]:6379"
+		Expect(GetAddr(str)).To(Equal(str))
+
+		Expect(GetAddr("::1:1234")).To(Equal("[::1]:1234"))
+
+		Expect(GetAddr("fd01:abcd::7d03:6379")).To(Equal("[fd01:abcd::7d03]:6379"))
+
+		Expect(GetAddr("127.0.0.1")).To(Equal(""))
+
+		Expect(GetAddr("127")).To(Equal(""))
+	})
+}
diff --git a/json.go b/json.go
new file mode 100644
index 000000000..ca731db3a
--- /dev/null
+++ b/json.go
@@ -0,0 +1,599 @@
+package redis
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+
+	"github.com/redis/go-redis/v9/internal/proto"
+	"github.com/redis/go-redis/v9/internal/util"
+)
+
+// -------------------------------------------
+
+type JSONCmdable interface {
+	JSONArrAppend(ctx context.Context, key, path string, values ...interface{}) *IntSliceCmd
+	JSONArrIndex(ctx context.Context, key, path string, value ...interface{}) *IntSliceCmd
+	JSONArrIndexWithArgs(ctx context.Context, key, path string, options *JSONArrIndexArgs, value ...interface{}) *IntSliceCmd
+	JSONArrInsert(ctx context.Context, key, path string, index int64, values ...interface{}) *IntSliceCmd
+	JSONArrLen(ctx context.Context, key, path string) *IntSliceCmd
+	JSONArrPop(ctx context.Context, key, path string, index int) *StringSliceCmd
+	JSONArrTrim(ctx context.Context, key, path string) *IntSliceCmd
+	JSONArrTrimWithArgs(ctx context.Context, key, path string, options *JSONArrTrimArgs) *IntSliceCmd
+	JSONClear(ctx context.Context, key, path string) *IntCmd
+	JSONDebugMemory(ctx context.Context, key, path string) *IntCmd
+	JSONDel(ctx context.Context, key, path string) *IntCmd
+	JSONForget(ctx context.Context, key, path string) *IntCmd
+	JSONGet(ctx context.Context, key string, paths ...string) *JSONCmd
+	JSONGetWithArgs(ctx context.Context, key string, options *JSONGetArgs, paths ...string) *JSONCmd
+	JSONMerge(ctx context.Context, key, path string, value string) *StatusCmd
+	JSONMSetArgs(ctx context.Context, docs []JSONSetArgs) *StatusCmd
+	JSONMSet(ctx context.Context, params ...interface{}) *StatusCmd
+	JSONMGet(ctx context.Context, path string, keys ...string) *JSONSliceCmd
+	JSONNumIncrBy(ctx context.Context, key, path string, value float64) *JSONCmd
+	JSONObjKeys(ctx context.Context, key, path string) *SliceCmd
+	JSONObjLen(ctx context.Context, key, path string) *IntPointerSliceCmd
+	JSONSet(ctx context.Context, key, path string, value interface{}) *StatusCmd
+	JSONSetMode(ctx context.Context, key, path string, value interface{}, mode string) *StatusCmd
+	JSONStrAppend(ctx context.Context, key, path, value string) *IntPointerSliceCmd
+	JSONStrLen(ctx context.Context, key, path string) *IntPointerSliceCmd
+	JSONToggle(ctx context.Context, key, path string) *IntPointerSliceCmd
+	JSONType(ctx context.Context, key, path string) *JSONSliceCmd
+}
+
+type JSONSetArgs struct {
+	Key   string
+	Path  string
+	Value interface{}
+}
+
+type JSONArrIndexArgs struct {
+	Start int
+	Stop  *int
+}
+
+type JSONArrTrimArgs struct {
+	Start int
+	Stop  *int
+}
+
+type JSONCmd struct {
+	baseCmd
+	val      string
+	expanded []interface{}
+}
+
+var _ Cmder = (*JSONCmd)(nil)
+
+func newJSONCmd(ctx context.Context, args ...interface{}) *JSONCmd {
+	return &JSONCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *JSONCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *JSONCmd) SetVal(val string) {
+	cmd.val = val
+}
+
+func (cmd *JSONCmd) Val() string {
+	if len(cmd.val) == 0 && cmd.expanded != nil {
+		val, err := json.Marshal(cmd.expanded)
+		if err != nil {
+			cmd.SetErr(err)
+			return ""
+		}
+		return string(val)
+
+	} else {
+		return cmd.val
+	}
+}
+
+func (cmd *JSONCmd) Result() (string, error) {
+	return cmd.Val(), cmd.Err()
+}
+
+func (cmd JSONCmd) Expanded() (interface{}, error) {
+	if len(cmd.val) != 0 && cmd.expanded == nil {
+		err := json.Unmarshal([]byte(cmd.val), &cmd.expanded)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return cmd.expanded, nil
+}
+
+func (cmd *JSONCmd) readReply(rd *proto.Reader) error {
+	// nil response from JSON.(M)GET (cmd.baseCmd.err will be "redis: nil")
+	if cmd.baseCmd.Err() == Nil {
+		cmd.val = ""
+		return Nil
+	}
+
+	if readType, err := rd.PeekReplyType(); err != nil {
+		return err
+	} else if readType == proto.RespArray {
+
+		size, err := rd.ReadArrayLen()
+		if err != nil {
+			return err
+		}
+
+		expanded := make([]interface{}, size)
+
+		for i := 0; i < size; i++ {
+			if expanded[i], err = rd.ReadReply(); err != nil {
+				return err
+			}
+		}
+		cmd.expanded = expanded
+
+	} else {
+		if str, err := rd.ReadString(); err != nil && err != Nil {
+			return err
+		} else if str == "" || err == Nil {
+			cmd.val = ""
+		} else {
+			cmd.val = str
+		}
+	}
+
+	return nil
+}
+
+// -------------------------------------------
+
+type JSONSliceCmd struct {
+	baseCmd
+	val []interface{}
+}
+
+func NewJSONSliceCmd(ctx context.Context, args ...interface{}) *JSONSliceCmd {
+	return &JSONSliceCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *JSONSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *JSONSliceCmd) SetVal(val []interface{}) {
+	cmd.val = val
+}
+
+func (cmd *JSONSliceCmd) Val() []interface{} {
+	return cmd.val
+}
+
+func (cmd *JSONSliceCmd) Result() ([]interface{}, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *JSONSliceCmd) readReply(rd *proto.Reader) error {
+	if cmd.baseCmd.Err() == Nil {
+		cmd.val = nil
+		return Nil
+	}
+
+	if readType, err := rd.PeekReplyType(); err != nil {
+		return err
+	} else if readType == proto.RespArray {
+		response, err := rd.ReadReply()
+		if err != nil {
+			return nil
+		} else {
+			cmd.val = response.([]interface{})
+		}
+
+	} else {
+		n, err := rd.ReadArrayLen()
+		if err != nil {
+			return err
+		}
+		cmd.val = make([]interface{}, n)
+		for i := 0; i < len(cmd.val); i++ {
+			switch s, err := rd.ReadString(); {
+			case err == Nil:
+				cmd.val[i] = ""
+			case err != nil:
+				return err
+			default:
+				cmd.val[i] = s
+			}
+		}
+	}
+	return nil
+}
+
+/*******************************************************************************
+*
+* IntPointerSliceCmd
+* used to represent a RedisJSON response where the result is either an integer or nil
+*
+*******************************************************************************/
+
+type IntPointerSliceCmd struct {
+	baseCmd
+	val []*int64
+}
+
+// NewIntPointerSliceCmd initialises an IntPointerSliceCmd
+func NewIntPointerSliceCmd(ctx context.Context, args ...interface{}) *IntPointerSliceCmd {
+	return &IntPointerSliceCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *IntPointerSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *IntPointerSliceCmd) SetVal(val []*int64) {
+	cmd.val = val
+}
+
+func (cmd *IntPointerSliceCmd) Val() []*int64 {
+	return cmd.val
+}
+
+func (cmd *IntPointerSliceCmd) Result() ([]*int64, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *IntPointerSliceCmd) readReply(rd *proto.Reader) error {
+	n, err := rd.ReadArrayLen()
+	if err != nil {
+		return err
+	}
+	cmd.val = make([]*int64, n)
+
+	for i := 0; i < len(cmd.val); i++ {
+		val, err := rd.ReadInt()
+		if err != nil && err != Nil {
+			return err
+		} else if err != Nil {
+			cmd.val[i] = &val
+		}
+	}
+
+	return nil
+}
+
+//------------------------------------------------------------------------------
+
+// JSONArrAppend adds the provided JSON values to the end of the array at the given path.
+// For more information, see https://redis.io/commands/json.arrappend
+func (c cmdable) JSONArrAppend(ctx context.Context, key, path string, values ...interface{}) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRAPPEND", key, path}
+	args = append(args, values...)
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrIndex searches for the first occurrence of the provided JSON value in the array at the given path.
+// For more information, see https://redis.io/commands/json.arrindex
+func (c cmdable) JSONArrIndex(ctx context.Context, key, path string, value ...interface{}) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRINDEX", key, path}
+	args = append(args, value...)
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrIndexWithArgs searches for the first occurrence of a JSON value in an array while allowing the start and
+// stop options to be provided.
+// For more information, see https://redis.io/commands/json.arrindex
+func (c cmdable) JSONArrIndexWithArgs(ctx context.Context, key, path string, options *JSONArrIndexArgs, value ...interface{}) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRINDEX", key, path}
+	args = append(args, value...)
+
+	if options != nil {
+		args = append(args, options.Start)
+		if options.Stop != nil {
+			args = append(args, *options.Stop)
+		}
+	}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrInsert inserts the JSON values into the array at the specified path before the index (shifts to the right).
+// For more information, see https://redis.io/commands/json.arrinsert
+func (c cmdable) JSONArrInsert(ctx context.Context, key, path string, index int64, values ...interface{}) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRINSERT", key, path, index}
+	args = append(args, values...)
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrLen reports the length of the JSON array at the specified path in the given key.
+// For more information, see https://redis.io/commands/json.arrlen
+func (c cmdable) JSONArrLen(ctx context.Context, key, path string) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRLEN", key, path}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrPop removes and returns an element from the specified index in the array.
+// For more information, see https://redis.io/commands/json.arrpop
+func (c cmdable) JSONArrPop(ctx context.Context, key, path string, index int) *StringSliceCmd {
+	args := []interface{}{"JSON.ARRPOP", key, path, index}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrTrim trims an array to contain only the specified inclusive range of elements.
+// For more information, see https://redis.io/commands/json.arrtrim
+func (c cmdable) JSONArrTrim(ctx context.Context, key, path string) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRTRIM", key, path}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONArrTrimWithArgs trims an array to contain only the specified inclusive range of elements.
+// For more information, see https://redis.io/commands/json.arrtrim
+func (c cmdable) JSONArrTrimWithArgs(ctx context.Context, key, path string, options *JSONArrTrimArgs) *IntSliceCmd {
+	args := []interface{}{"JSON.ARRTRIM", key, path}
+
+	if options != nil {
+		args = append(args, options.Start)
+
+		if options.Stop != nil {
+			args = append(args, *options.Stop)
+		}
+	}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONClear clears container values (arrays/objects) and sets numeric values to 0.
+// For more information, see https://redis.io/commands/json.clear
+func (c cmdable) JSONClear(ctx context.Context, key, path string) *IntCmd {
+	args := []interface{}{"JSON.CLEAR", key, path}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONDebugMemory reports a value's memory usage in bytes (unimplemented)
+// For more information, see https://redis.io/commands/json.debug-memory
+func (c cmdable) JSONDebugMemory(ctx context.Context, key, path string) *IntCmd {
+	panic("not implemented")
+}
+
+// JSONDel deletes a value.
+// For more information, see https://redis.io/commands/json.del
+func (c cmdable) JSONDel(ctx context.Context, key, path string) *IntCmd {
+	args := []interface{}{"JSON.DEL", key, path}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONForget deletes a value.
+// For more information, see https://redis.io/commands/json.forget
+func (c cmdable) JSONForget(ctx context.Context, key, path string) *IntCmd {
+	args := []interface{}{"JSON.FORGET", key, path}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONGet returns the value at path in JSON serialized form. JSON.GET returns an
+// array of strings. This function parses out the wrapping array but leaves the
+// internal strings unprocessed by default (see Val())
+// For more information - https://redis.io/commands/json.get/
+func (c cmdable) JSONGet(ctx context.Context, key string, paths ...string) *JSONCmd {
+	args := make([]interface{}, len(paths)+2)
+	args[0] = "JSON.GET"
+	args[1] = key
+	for n, path := range paths {
+		args[n+2] = path
+	}
+	cmd := newJSONCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type JSONGetArgs struct {
+	Indent  string
+	Newline string
+	Space   string
+}
+
+// JSONGetWithArgs - Retrieves the value of a key from a JSON document.
+// This function also allows for specifying additional options such as:
+// Indention, NewLine and Space
+// For more information - https://redis.io/commands/json.get/
+func (c cmdable) JSONGetWithArgs(ctx context.Context, key string, options *JSONGetArgs, paths ...string) *JSONCmd {
+	args := []interface{}{"JSON.GET", key}
+	if options != nil {
+		if options.Indent != "" {
+			args = append(args, "INDENT", options.Indent)
+		}
+		if options.Newline != "" {
+			args = append(args, "NEWLINE", options.Newline)
+		}
+		if options.Space != "" {
+			args = append(args, "SPACE", options.Space)
+		}
+		for _, path := range paths {
+			args = append(args, path)
+		}
+	}
+	cmd := newJSONCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONMerge merges a given JSON value into matching paths.
+// For more information, see https://redis.io/commands/json.merge
+func (c cmdable) JSONMerge(ctx context.Context, key, path string, value string) *StatusCmd {
+	args := []interface{}{"JSON.MERGE", key, path, value}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONMGet returns the values at the specified path from multiple key arguments.
+// Note - the arguments are reversed when compared with `JSON.MGET` as we want
+// to follow the pattern of having the last argument be variable.
+// For more information, see https://redis.io/commands/json.mget
+func (c cmdable) JSONMGet(ctx context.Context, path string, keys ...string) *JSONSliceCmd {
+	args := make([]interface{}, len(keys)+1)
+	args[0] = "JSON.MGET"
+	for n, key := range keys {
+		args[n+1] = key
+	}
+	args = append(args, path)
+	cmd := NewJSONSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONMSetArgs sets or updates one or more JSON values according to the specified key-path-value triplets.
+// For more information, see https://redis.io/commands/json.mset
+func (c cmdable) JSONMSetArgs(ctx context.Context, docs []JSONSetArgs) *StatusCmd {
+	args := []interface{}{"JSON.MSET"}
+	for _, doc := range docs {
+		args = append(args, doc.Key, doc.Path, doc.Value)
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) JSONMSet(ctx context.Context, params ...interface{}) *StatusCmd {
+	args := []interface{}{"JSON.MSET"}
+	args = append(args, params...)
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONNumIncrBy increments the number value stored at the specified path by the provided number.
+// For more information, see https://redis.io/commands/json.numincreby
+func (c cmdable) JSONNumIncrBy(ctx context.Context, key, path string, value float64) *JSONCmd {
+	args := []interface{}{"JSON.NUMINCRBY", key, path, value}
+	cmd := newJSONCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONObjKeys returns the keys in the object that's referenced by the specified path.
+// For more information, see https://redis.io/commands/json.objkeys
+func (c cmdable) JSONObjKeys(ctx context.Context, key, path string) *SliceCmd {
+	args := []interface{}{"JSON.OBJKEYS", key, path}
+	cmd := NewSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONObjLen reports the number of keys in the JSON object at the specified path in the given key.
+// For more information, see https://redis.io/commands/json.objlen
+func (c cmdable) JSONObjLen(ctx context.Context, key, path string) *IntPointerSliceCmd {
+	args := []interface{}{"JSON.OBJLEN", key, path}
+	cmd := NewIntPointerSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONSet sets the JSON value at the given path in the given key. The value must be something that
+// can be marshaled to JSON (using encoding/JSON) unless the argument is a string or a []byte when we assume that
+// it can be passed directly as JSON.
+// For more information, see https://redis.io/commands/json.set
+func (c cmdable) JSONSet(ctx context.Context, key, path string, value interface{}) *StatusCmd {
+	return c.JSONSetMode(ctx, key, path, value, "")
+}
+
+// JSONSetMode sets the JSON value at the given path in the given key and allows the mode to be set
+// (the mode value must be "XX" or "NX"). The value must be something that can be marshaled to JSON (using encoding/JSON) unless
+// the argument is a string or []byte when we assume that it can be passed directly as JSON.
+// For more information, see https://redis.io/commands/json.set
+func (c cmdable) JSONSetMode(ctx context.Context, key, path string, value interface{}, mode string) *StatusCmd {
+	var bytes []byte
+	var err error
+	switch v := value.(type) {
+	case string:
+		bytes = []byte(v)
+	case []byte:
+		bytes = v
+	default:
+		bytes, err = json.Marshal(v)
+	}
+	args := []interface{}{"JSON.SET", key, path, util.BytesToString(bytes)}
+	if mode != "" {
+		switch strings.ToUpper(mode) {
+		case "XX", "NX":
+			args = append(args, strings.ToUpper(mode))
+
+		default:
+			panic("redis: JSON.SET mode must be NX or XX")
+		}
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	if err != nil {
+		cmd.SetErr(err)
+	} else {
+		_ = c(ctx, cmd)
+	}
+	return cmd
+}
+
+// JSONStrAppend appends the JSON-string values to the string at the specified path.
+// For more information, see https://redis.io/commands/json.strappend
+func (c cmdable) JSONStrAppend(ctx context.Context, key, path, value string) *IntPointerSliceCmd {
+	args := []interface{}{"JSON.STRAPPEND", key, path, value}
+	cmd := NewIntPointerSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONStrLen reports the length of the JSON String at the specified path in the given key.
+// For more information, see https://redis.io/commands/json.strlen
+func (c cmdable) JSONStrLen(ctx context.Context, key, path string) *IntPointerSliceCmd {
+	args := []interface{}{"JSON.STRLEN", key, path}
+	cmd := NewIntPointerSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONToggle toggles a Boolean value stored at the specified path.
+// For more information, see https://redis.io/commands/json.toggle
+func (c cmdable) JSONToggle(ctx context.Context, key, path string) *IntPointerSliceCmd {
+	args := []interface{}{"JSON.TOGGLE", key, path}
+	cmd := NewIntPointerSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// JSONType reports the type of JSON value at the specified path.
+// For more information, see https://redis.io/commands/json.type
+func (c cmdable) JSONType(ctx context.Context, key, path string) *JSONSliceCmd {
+	args := []interface{}{"JSON.TYPE", key, path}
+	cmd := NewJSONSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/json_test.go b/json_test.go
new file mode 100644
index 000000000..4e9718a4e
--- /dev/null
+++ b/json_test.go
@@ -0,0 +1,660 @@
+package redis_test
+
+import (
+	"context"
+
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+
+	"github.com/redis/go-redis/v9"
+)
+
+type JSONGetTestStruct struct {
+	Hello string `json:"hello"`
+}
+
+var _ = Describe("JSON Commands", Label("json"), func() {
+	ctx := context.TODO()
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(&redis.Options{Addr: ":6379"})
+		Expect(client.FlushAll(ctx).Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	Describe("arrays", Label("arrays"), func() {
+		It("should JSONArrAppend", Label("json.arrappend", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "append2", "$", `{"a": [10], "b": {"a": [12, 13]}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONArrAppend(ctx, "append2", "$..a", 10)
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal([]int64{2, 3}))
+		})
+
+		It("should JSONArrIndex and JSONArrIndexWithArgs", Label("json.arrindex", "json"), func() {
+			cmd1, err := client.JSONSet(ctx, "index1", "$", `{"a": [10], "b": {"a": [12, 10]}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd1).To(Equal("OK"))
+
+			cmd2, err := client.JSONArrIndex(ctx, "index1", "$.b.a", 10).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd2).To(Equal([]int64{1}))
+
+			cmd3, err := client.JSONSet(ctx, "index2", "$", `[0,1,2,3,4]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd3).To(Equal("OK"))
+
+			res, err := client.JSONArrIndex(ctx, "index2", "$", 1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res[0]).To(Equal(int64(1)))
+
+			res, err = client.JSONArrIndex(ctx, "index2", "$", 1, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res[0]).To(Equal(int64(-1)))
+
+			res, err = client.JSONArrIndex(ctx, "index2", "$", 4).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res[0]).To(Equal(int64(4)))
+
+			res, err = client.JSONArrIndexWithArgs(ctx, "index2", "$", &redis.JSONArrIndexArgs{}, 4).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res[0]).To(Equal(int64(4)))
+
+			stop := 5000
+			res, err = client.JSONArrIndexWithArgs(ctx, "index2", "$", &redis.JSONArrIndexArgs{Stop: &stop}, 4).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res[0]).To(Equal(int64(4)))
+
+			stop = -1
+			res, err = client.JSONArrIndexWithArgs(ctx, "index2", "$", &redis.JSONArrIndexArgs{Stop: &stop}, 4).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res[0]).To(Equal(int64(-1)))
+		})
+
+		It("should JSONArrIndex and JSONArrIndexWithArgs with $", Label("json.arrindex", "json"), func() {
+			doc := `{
+				"store": {
+					"book": [
+						{
+							"category": "reference",
+							"author": "Nigel Rees",
+							"title": "Sayings of the Century",
+							"price": 8.95,
+							"size": [10, 20, 30, 40]
+						},
+						{
+							"category": "fiction",
+							"author": "Evelyn Waugh",
+							"title": "Sword of Honour",
+							"price": 12.99,
+							"size": [50, 60, 70, 80]
+						},
+						{
+							"category": "fiction",
+							"author": "Herman Melville",
+							"title": "Moby Dick",
+							"isbn": "0-553-21311-3",
+							"price": 8.99,
+							"size": [5, 10, 20, 30]
+						},
+						{
+							"category": "fiction",
+							"author": "J. R. R. Tolkien",
+							"title": "The Lord of the Rings",
+							"isbn": "0-395-19395-8",
+							"price": 22.99,
+							"size": [5, 6, 7, 8]
+						}
+					],
+					"bicycle": {"color": "red", "price": 19.95}
+				}
+			}`
+			res, err := client.JSONSet(ctx, "doc1", "$", doc).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			resGet, err := client.JSONGet(ctx, "doc1", "$.store.book[?(@.price<10)].size").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal("[[10,20,30,40],[5,10,20,30]]"))
+
+			resArr, err := client.JSONArrIndex(ctx, "doc1", "$.store.book[?(@.price<10)].size", 20).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resArr).To(Equal([]int64{1, 2}))
+		})
+
+		It("should JSONArrInsert", Label("json.arrinsert", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "insert2", "$", `[100, 200, 300, 200]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONArrInsert(ctx, "insert2", "$", -1, 1, 2)
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal([]int64{6}))
+
+			cmd3 := client.JSONGet(ctx, "insert2")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			// RESP2 vs RESP3
+			Expect(cmd3.Val()).To(Or(
+				Equal(`[100,200,300,1,2,200]`),
+				Equal(`[[100,200,300,1,2,200]]`)))
+		})
+
+		It("should JSONArrLen", Label("json.arrlen", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "length2", "$", `{"a": [10], "b": {"a": [12, 10, 20, 12, 90, 10]}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONArrLen(ctx, "length2", "$..a")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal([]int64{1, 6}))
+		})
+
+		It("should JSONArrPop", Label("json.arrpop"), func() {
+			cmd1 := client.JSONSet(ctx, "pop4", "$", `[100, 200, 300, 200]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONArrPop(ctx, "pop4", "$", 2)
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal([]string{"300"}))
+
+			cmd3 := client.JSONGet(ctx, "pop4", "$")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			Expect(cmd3.Val()).To(Equal("[[100,200,200]]"))
+		})
+
+		It("should JSONArrTrim", Label("json.arrtrim", "json"), func() {
+			cmd1, err := client.JSONSet(ctx, "trim1", "$", `[0,1,2,3,4]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd1).To(Equal("OK"))
+
+			stop := 3
+			cmd2, err := client.JSONArrTrimWithArgs(ctx, "trim1", "$", &redis.JSONArrTrimArgs{Start: 1, Stop: &stop}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd2).To(Equal([]int64{3}))
+
+			res, err := client.JSONGet(ctx, "trim1", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[[1,2,3]]`))
+
+			cmd3, err := client.JSONSet(ctx, "trim2", "$", `[0,1,2,3,4]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd3).To(Equal("OK"))
+
+			stop = 3
+			cmd4, err := client.JSONArrTrimWithArgs(ctx, "trim2", "$", &redis.JSONArrTrimArgs{Start: -1, Stop: &stop}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd4).To(Equal([]int64{0}))
+
+			cmd5, err := client.JSONSet(ctx, "trim3", "$", `[0,1,2,3,4]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd5).To(Equal("OK"))
+
+			stop = 99
+			cmd6, err := client.JSONArrTrimWithArgs(ctx, "trim3", "$", &redis.JSONArrTrimArgs{Start: 3, Stop: &stop}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd6).To(Equal([]int64{2}))
+
+			cmd7, err := client.JSONSet(ctx, "trim4", "$", `[0,1,2,3,4]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd7).To(Equal("OK"))
+
+			stop = 1
+			cmd8, err := client.JSONArrTrimWithArgs(ctx, "trim4", "$", &redis.JSONArrTrimArgs{Start: 9, Stop: &stop}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd8).To(Equal([]int64{0}))
+
+			cmd9, err := client.JSONSet(ctx, "trim5", "$", `[0,1,2,3,4]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd9).To(Equal("OK"))
+
+			stop = 11
+			cmd10, err := client.JSONArrTrimWithArgs(ctx, "trim5", "$", &redis.JSONArrTrimArgs{Start: 9, Stop: &stop}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd10).To(Equal([]int64{0}))
+		})
+
+		It("should JSONArrPop", Label("json.arrpop", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "pop4", "$", `[100, 200, 300, 200]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONArrPop(ctx, "pop4", "$", 2)
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal([]string{"300"}))
+
+			cmd3 := client.JSONGet(ctx, "pop4", "$")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			Expect(cmd3.Val()).To(Equal("[[100,200,200]]"))
+		})
+	})
+
+	Describe("get/set", Label("getset"), func() {
+		It("should JSONSet", Label("json.set", "json"), func() {
+			cmd := client.JSONSet(ctx, "set1", "$", `{"a": 1, "b": 2, "hello": "world"}`)
+			Expect(cmd.Err()).NotTo(HaveOccurred())
+			Expect(cmd.Val()).To(Equal("OK"))
+		})
+
+		It("should JSONGet", Label("json.get", "json"), func() {
+			res, err := client.JSONSet(ctx, "get3", "$", `{"a": 1, "b": 2}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			res, err = client.JSONGetWithArgs(ctx, "get3", &redis.JSONGetArgs{Indent: "-"}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[-{--"a":1,--"b":2-}]`))
+
+			res, err = client.JSONGetWithArgs(ctx, "get3", &redis.JSONGetArgs{Indent: "-", Newline: `~`, Space: `!`}).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[~-{~--"a":!1,~--"b":!2~-}~]`))
+		})
+
+		It("should JSONMerge", Label("json.merge", "json"), func() {
+			res, err := client.JSONSet(ctx, "merge1", "$", `{"a": 1, "b": 2}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			res, err = client.JSONMerge(ctx, "merge1", "$", `{"b": 3, "c": 4}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			res, err = client.JSONGet(ctx, "merge1", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[{"a":1,"b":3,"c":4}]`))
+		})
+
+		It("should JSONMSet", Label("json.mset", "json", "NonRedisEnterprise"), func() {
+			doc1 := redis.JSONSetArgs{Key: "mset1", Path: "$", Value: `{"a": 1}`}
+			doc2 := redis.JSONSetArgs{Key: "mset2", Path: "$", Value: 2}
+			docs := []redis.JSONSetArgs{doc1, doc2}
+
+			mSetResult, err := client.JSONMSetArgs(ctx, docs).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(mSetResult).To(Equal("OK"))
+
+			res, err := client.JSONMGet(ctx, "$", "mset1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal([]interface{}{`[{"a":1}]`}))
+
+			res, err = client.JSONMGet(ctx, "$", "mset1", "mset2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal([]interface{}{`[{"a":1}]`, "[2]"}))
+
+			_, err = client.JSONMSet(ctx, "mset1", "$.a", 2, "mset3", "$", `[1]`).Result()
+			Expect(err).NotTo(HaveOccurred())
+		})
+
+		It("should JSONMGet", Label("json.mget", "json", "NonRedisEnterprise"), func() {
+			cmd1 := client.JSONSet(ctx, "mget2a", "$", `{"a": ["aa", "ab", "ac", "ad"], "b": {"a": ["ba", "bb", "bc", "bd"]}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+			cmd2 := client.JSONSet(ctx, "mget2b", "$", `{"a": [100, 200, 300, 200], "b": {"a": [100, 200, 300, 200]}}`)
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal("OK"))
+
+			cmd3 := client.JSONMGet(ctx, "$..a", "mget2a", "mget2b")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			Expect(cmd3.Val()).To(HaveLen(2))
+			Expect(cmd3.Val()[0]).To(Equal(`[["aa","ab","ac","ad"],["ba","bb","bc","bd"]]`))
+			Expect(cmd3.Val()[1]).To(Equal(`[[100,200,300,200],[100,200,300,200]]`))
+		})
+
+		It("should JSONMget with $", Label("json.mget", "json", "NonRedisEnterprise"), func() {
+			res, err := client.JSONSet(ctx, "doc1", "$", `{"a": 1, "b": 2, "nested": {"a": 3}, "c": "", "nested2": {"a": ""}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			res, err = client.JSONSet(ctx, "doc2", "$", `{"a": 4, "b": 5, "nested": {"a": 6}, "c": "", "nested2": {"a": [""]}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err := client.JSONMGet(ctx, "$..a", "doc1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal([]interface{}{`[1,3,""]`}))
+
+			iRes, err = client.JSONMGet(ctx, "$..a", "doc1", "doc2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal([]interface{}{`[1,3,""]`, `[4,6,[""]]`}))
+
+			iRes, err = client.JSONMGet(ctx, "$..a", "non_existing_doc", "non_existing_doc1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal([]interface{}{nil, nil}))
+		})
+	})
+
+	Describe("Misc", Label("misc"), func() {
+		It("should JSONClear", Label("json.clear", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "clear1", "$", `[1]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONClear(ctx, "clear1", "$")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal(int64(1)))
+
+			cmd3 := client.JSONGet(ctx, "clear1", "$")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			Expect(cmd3.Val()).To(Equal(`[[]]`))
+		})
+
+		It("should JSONClear with $", Label("json.clear", "json"), func() {
+			doc := `{
+				"nested1": {"a": {"foo": 10, "bar": 20}},
+				"a": ["foo"],
+				"nested2": {"a": "claro"},
+				"nested3": {"a": {"baz": 50}}
+			}`
+			res, err := client.JSONSet(ctx, "doc1", "$", doc).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err := client.JSONClear(ctx, "doc1", "$..a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(3)))
+
+			resGet, err := client.JSONGet(ctx, "doc1", `$`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(`[{"nested1":{"a":{}},"a":[],"nested2":{"a":"claro"},"nested3":{"a":{}}}]`))
+
+			res, err = client.JSONSet(ctx, "doc1", "$", doc).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err = client.JSONClear(ctx, "doc1", "$.nested1.a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(1)))
+
+			resGet, err = client.JSONGet(ctx, "doc1", `$`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(`[{"nested1":{"a":{}},"a":["foo"],"nested2":{"a":"claro"},"nested3":{"a":{"baz":50}}}]`))
+		})
+
+		It("should JSONDel", Label("json.del", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "del1", "$", `[1]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONDel(ctx, "del1", "$")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal(int64(1)))
+
+			cmd3 := client.JSONGet(ctx, "del1", "$")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			Expect(cmd3.Val()).To(HaveLen(0))
+		})
+
+		It("should JSONDel with $", Label("json.del", "json"), func() {
+			res, err := client.JSONSet(ctx, "del1", "$", `{"a": 1, "nested": {"a": 2, "b": 3}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err := client.JSONDel(ctx, "del1", "$..a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(2)))
+
+			resGet, err := client.JSONGet(ctx, "del1", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(`[{"nested":{"b":3}}]`))
+
+			res, err = client.JSONSet(ctx, "del2", "$", `{"a": {"a": 2, "b": 3}, "b": ["a", "b"], "nested": {"b": [true, "a", "b"]}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err = client.JSONDel(ctx, "del2", "$..a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(1)))
+
+			resGet, err = client.JSONGet(ctx, "del2", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(`[{"nested":{"b":[true,"a","b"]},"b":["a","b"]}]`))
+
+			doc := `[
+				{
+					"ciao": ["non ancora"],
+					"nested": [
+						{"ciao": [1, "a"]},
+						{"ciao": [2, "a"]},
+						{"ciaoc": [3, "non", "ciao"]},
+						{"ciao": [4, "a"]},
+						{"e": [5, "non", "ciao"]}
+					]
+				}
+			]`
+			res, err = client.JSONSet(ctx, "del3", "$", doc).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err = client.JSONDel(ctx, "del3", `$.[0]["nested"]..ciao`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(3)))
+
+			resVal := `[[{"ciao":["non ancora"],"nested":[{},{},{"ciaoc":[3,"non","ciao"]},{},{"e":[5,"non","ciao"]}]}]]`
+			resGet, err = client.JSONGet(ctx, "del3", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(resVal))
+		})
+
+		It("should JSONForget", Label("json.forget", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "forget3", "$", `{"a": [1,2,3], "b": {"a": [1,2,3], "b": "annie"}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONForget(ctx, "forget3", "$..a")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal(int64(2)))
+
+			cmd3 := client.JSONGet(ctx, "forget3", "$")
+			Expect(cmd3.Err()).NotTo(HaveOccurred())
+			Expect(cmd3.Val()).To(Equal(`[{"b":{"b":"annie"}}]`))
+		})
+
+		It("should JSONForget with $", Label("json.forget", "json"), func() {
+			res, err := client.JSONSet(ctx, "doc1", "$", `{"a": 1, "nested": {"a": 2, "b": 3}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err := client.JSONForget(ctx, "doc1", "$..a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(2)))
+
+			resGet, err := client.JSONGet(ctx, "doc1", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(`[{"nested":{"b":3}}]`))
+
+			res, err = client.JSONSet(ctx, "doc2", "$", `{"a": {"a": 2, "b": 3}, "b": ["a", "b"], "nested": {"b": [true, "a", "b"]}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err = client.JSONForget(ctx, "doc2", "$..a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(1)))
+
+			resGet, err = client.JSONGet(ctx, "doc2", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(`[{"nested":{"b":[true,"a","b"]},"b":["a","b"]}]`))
+
+			doc := `[
+				{
+					"ciao": ["non ancora"],
+					"nested": [
+						{"ciao": [1, "a"]},
+						{"ciao": [2, "a"]},
+						{"ciaoc": [3, "non", "ciao"]},
+						{"ciao": [4, "a"]},
+						{"e": [5, "non", "ciao"]}
+					]
+				}
+			]`
+			res, err = client.JSONSet(ctx, "doc3", "$", doc).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			iRes, err = client.JSONForget(ctx, "doc3", `$.[0]["nested"]..ciao`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(iRes).To(Equal(int64(3)))
+
+			resVal := `[[{"ciao":["non ancora"],"nested":[{},{},{"ciaoc":[3,"non","ciao"]},{},{"e":[5,"non","ciao"]}]}]]`
+			resGet, err = client.JSONGet(ctx, "doc3", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resGet).To(Equal(resVal))
+		})
+
+		It("should JSONNumIncrBy", Label("json.numincrby", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "incr3", "$", `{"a": [1, 2], "b": {"a": [0, -1]}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONNumIncrBy(ctx, "incr3", "$..a[1]", float64(1))
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(Equal(`[3,0]`))
+		})
+
+		It("should JSONNumIncrBy with $", Label("json.numincrby", "json"), func() {
+			res, err := client.JSONSet(ctx, "doc1", "$", `{"a": "b", "b": [{"a": 2}, {"a": 5.0}, {"a": "c"}]}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			res, err = client.JSONNumIncrBy(ctx, "doc1", "$.b[1].a", 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[7]`))
+
+			res, err = client.JSONNumIncrBy(ctx, "doc1", "$.b[1].a", 3.5).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[10.5]`))
+
+			res, err = client.JSONSet(ctx, "doc2", "$", `{"a": "b", "b": [{"a": 2}, {"a": 5.0}, {"a": "c"}]}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			res, err = client.JSONNumIncrBy(ctx, "doc2", "$.b[0].a", 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal(`[5]`))
+		})
+
+		It("should JSONObjKeys", Label("json.objkeys", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "objkeys1", "$", `{"a": [1, 2], "b": {"a": [0, -1]}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONObjKeys(ctx, "objkeys1", "$..*")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(HaveLen(7))
+			Expect(cmd2.Val()).To(Equal([]interface{}{nil, []interface{}{"a"}, nil, nil, nil, nil, nil}))
+		})
+
+		It("should JSONObjKeys with $", Label("json.objkeys", "json"), func() {
+			doc := `{
+				"nested1": {"a": {"foo": 10, "bar": 20}},
+				"a": ["foo"],
+				"nested2": {"a": {"baz": 50}}
+			}`
+			cmd1, err := client.JSONSet(ctx, "objkeys1", "$", doc).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd1).To(Equal("OK"))
+
+			cmd2, err := client.JSONObjKeys(ctx, "objkeys1", "$.nested1.a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd2).To(Equal([]interface{}{[]interface{}{"foo", "bar"}}))
+
+			cmd2, err = client.JSONObjKeys(ctx, "objkeys1", ".*.a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd2).To(Equal([]interface{}{"foo", "bar"}))
+
+			cmd2, err = client.JSONObjKeys(ctx, "objkeys1", ".nested2.a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd2).To(Equal([]interface{}{"baz"}))
+
+			_, err = client.JSONObjKeys(ctx, "non_existing_doc", "..a").Result()
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("should JSONObjLen", Label("json.objlen", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "objlen2", "$", `{"a": [1, 2], "b": {"a": [0, -1]}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONObjLen(ctx, "objlen2", "$..*")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(HaveLen(7))
+			Expect(cmd2.Val()[0]).To(BeNil())
+			Expect(*cmd2.Val()[1]).To(Equal(int64(1)))
+		})
+
+		It("should JSONStrLen", Label("json.strlen", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "strlen2", "$", `{"a": "alice", "b": "bob", "c": {"a": "alice", "b": "bob"}}`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONStrLen(ctx, "strlen2", "$..*")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(HaveLen(5))
+			var tmp int64 = 20
+			Expect(cmd2.Val()[0]).To(BeAssignableToTypeOf(&tmp))
+			Expect(*cmd2.Val()[0]).To(Equal(int64(5)))
+			Expect(*cmd2.Val()[1]).To(Equal(int64(3)))
+			Expect(cmd2.Val()[2]).To(BeNil())
+			Expect(*cmd2.Val()[3]).To(Equal(int64(5)))
+			Expect(*cmd2.Val()[4]).To(Equal(int64(3)))
+		})
+
+		It("should JSONStrAppend", Label("json.strappend", "json"), func() {
+			cmd1, err := client.JSONSet(ctx, "strapp1", "$", `"foo"`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd1).To(Equal("OK"))
+			cmd2, err := client.JSONStrAppend(ctx, "strapp1", "$", `"bar"`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(*cmd2[0]).To(Equal(int64(6)))
+			cmd3, err := client.JSONGet(ctx, "strapp1", "$").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cmd3).To(Equal(`["foobar"]`))
+		})
+
+		It("should JSONStrAppend and JSONStrLen with $", Label("json.strappend", "json.strlen", "json"), func() {
+			res, err := client.JSONSet(ctx, "doc1", "$", `{"a": "foo", "nested1": {"a": "hello"}, "nested2": {"a": 31}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			intArrayResult, err := client.JSONStrAppend(ctx, "doc1", "$.nested1.a", `"baz"`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(*intArrayResult[0]).To(Equal(int64(8)))
+
+			res, err = client.JSONSet(ctx, "doc2", "$", `{"a": "foo", "nested1": {"a": "hello"}, "nested2": {"a": 31}}`).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(res).To(Equal("OK"))
+
+			intResult, err := client.JSONStrLen(ctx, "doc2", "$.nested1.a").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(*intResult[0]).To(Equal(int64(5)))
+		})
+
+		It("should JSONToggle", Label("json.toggle", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "toggle1", "$", `[true]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONToggle(ctx, "toggle1", "$[0]")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(HaveLen(1))
+			Expect(*cmd2.Val()[0]).To(Equal(int64(0)))
+		})
+
+		It("should JSONType", Label("json.type", "json"), func() {
+			cmd1 := client.JSONSet(ctx, "type1", "$", `[true]`)
+			Expect(cmd1.Err()).NotTo(HaveOccurred())
+			Expect(cmd1.Val()).To(Equal("OK"))
+
+			cmd2 := client.JSONType(ctx, "type1", "$[0]")
+			Expect(cmd2.Err()).NotTo(HaveOccurred())
+			Expect(cmd2.Val()).To(HaveLen(1))
+			// RESP2 v RESP3
+			Expect(cmd2.Val()[0]).To(Or(Equal([]interface{}{"boolean"}), Equal("boolean")))
+		})
+	})
+})
diff --git a/list_commands.go b/list_commands.go
new file mode 100644
index 000000000..24a0de081
--- /dev/null
+++ b/list_commands.go
@@ -0,0 +1,289 @@
+package redis
+
+import (
+	"context"
+	"strings"
+	"time"
+)
+
+type ListCmdable interface {
+	BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
+	BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd
+	BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd
+	BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd
+	LIndex(ctx context.Context, key string, index int64) *StringCmd
+	LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd
+	LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd
+	LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd
+	LLen(ctx context.Context, key string) *IntCmd
+	LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd
+	LPop(ctx context.Context, key string) *StringCmd
+	LPopCount(ctx context.Context, key string, count int) *StringSliceCmd
+	LPos(ctx context.Context, key string, value string, args LPosArgs) *IntCmd
+	LPosCount(ctx context.Context, key string, value string, count int64, args LPosArgs) *IntSliceCmd
+	LPush(ctx context.Context, key string, values ...interface{}) *IntCmd
+	LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
+	LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
+	LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd
+	LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd
+	LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd
+	RPop(ctx context.Context, key string) *StringCmd
+	RPopCount(ctx context.Context, key string, count int) *StringSliceCmd
+	RPopLPush(ctx context.Context, source, destination string) *StringCmd
+	RPush(ctx context.Context, key string, values ...interface{}) *IntCmd
+	RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd
+	LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd
+	BLMove(ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration) *StringCmd
+}
+
+func (c cmdable) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys)+1)
+	args[0] = "blpop"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	args[len(args)-1] = formatSec(ctx, timeout)
+	cmd := NewStringSliceCmd(ctx, args...)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) BLMPop(ctx context.Context, timeout time.Duration, direction string, count int64, keys ...string) *KeyValuesCmd {
+	args := make([]interface{}, 3+len(keys), 6+len(keys))
+	args[0] = "blmpop"
+	args[1] = formatSec(ctx, timeout)
+	args[2] = len(keys)
+	for i, key := range keys {
+		args[3+i] = key
+	}
+	args = append(args, strings.ToLower(direction), "count", count)
+	cmd := NewKeyValuesCmd(ctx, args...)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys)+1)
+	args[0] = "brpop"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	args[len(keys)+1] = formatSec(ctx, timeout)
+	cmd := NewStringSliceCmd(ctx, args...)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) BRPopLPush(ctx context.Context, source, destination string, timeout time.Duration) *StringCmd {
+	cmd := NewStringCmd(
+		ctx,
+		"brpoplpush",
+		source,
+		destination,
+		formatSec(ctx, timeout),
+	)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LIndex(ctx context.Context, key string, index int64) *StringCmd {
+	cmd := NewStringCmd(ctx, "lindex", key, index)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// LMPop Pops one or more elements from the first non-empty list key from the list of provided key names.
+// direction: left or right, count: > 0
+// example: client.LMPop(ctx, "left", 3, "key1", "key2")
+func (c cmdable) LMPop(ctx context.Context, direction string, count int64, keys ...string) *KeyValuesCmd {
+	args := make([]interface{}, 2+len(keys), 5+len(keys))
+	args[0] = "lmpop"
+	args[1] = len(keys)
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	args = append(args, strings.ToLower(direction), "count", count)
+	cmd := NewKeyValuesCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LInsert(ctx context.Context, key, op string, pivot, value interface{}) *IntCmd {
+	cmd := NewIntCmd(ctx, "linsert", key, op, pivot, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LInsertBefore(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
+	cmd := NewIntCmd(ctx, "linsert", key, "before", pivot, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LInsertAfter(ctx context.Context, key string, pivot, value interface{}) *IntCmd {
+	cmd := NewIntCmd(ctx, "linsert", key, "after", pivot, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LLen(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "llen", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LPop(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "lpop", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LPopCount(ctx context.Context, key string, count int) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "lpop", key, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type LPosArgs struct {
+	Rank, MaxLen int64
+}
+
+func (c cmdable) LPos(ctx context.Context, key string, value string, a LPosArgs) *IntCmd {
+	args := []interface{}{"lpos", key, value}
+	if a.Rank != 0 {
+		args = append(args, "rank", a.Rank)
+	}
+	if a.MaxLen != 0 {
+		args = append(args, "maxlen", a.MaxLen)
+	}
+
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LPosCount(ctx context.Context, key string, value string, count int64, a LPosArgs) *IntSliceCmd {
+	args := []interface{}{"lpos", key, value, "count", count}
+	if a.Rank != 0 {
+		args = append(args, "rank", a.Rank)
+	}
+	if a.MaxLen != 0 {
+		args = append(args, "maxlen", a.MaxLen)
+	}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "lpush"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "lpushx"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd(
+		ctx,
+		"lrange",
+		key,
+		start,
+		stop,
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LRem(ctx context.Context, key string, count int64, value interface{}) *IntCmd {
+	cmd := NewIntCmd(ctx, "lrem", key, count, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LSet(ctx context.Context, key string, index int64, value interface{}) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "lset", key, index, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LTrim(ctx context.Context, key string, start, stop int64) *StatusCmd {
+	cmd := NewStatusCmd(
+		ctx,
+		"ltrim",
+		key,
+		start,
+		stop,
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RPop(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "rpop", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RPopCount(ctx context.Context, key string, count int) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "rpop", key, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RPopLPush(ctx context.Context, source, destination string) *StringCmd {
+	cmd := NewStringCmd(ctx, "rpoplpush", source, destination)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RPush(ctx context.Context, key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "rpush"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) RPushX(ctx context.Context, key string, values ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "rpushx"
+	args[1] = key
+	args = appendArgs(args, values)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LMove(ctx context.Context, source, destination, srcpos, destpos string) *StringCmd {
+	cmd := NewStringCmd(ctx, "lmove", source, destination, srcpos, destpos)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) BLMove(
+	ctx context.Context, source, destination, srcpos, destpos string, timeout time.Duration,
+) *StringCmd {
+	cmd := NewStringCmd(ctx, "blmove", source, destination, srcpos, destpos, formatSec(ctx, timeout))
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/main_test.go b/main_test.go
index 8e87d76f8..19e944446 100644
--- a/main_test.go
+++ b/main_test.go
@@ -6,6 +6,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strconv"
 	"sync"
 	"testing"
 	"time"
@@ -36,8 +37,15 @@ const (
 	sentinelPort3      = "9128"
 )
 
-var redisPort = "6380"
-var redisAddr = ":" + redisPort
+var (
+	redisPort = "6380"
+	redisAddr = ":" + redisPort
+)
+
+var (
+	rediStackPort = "6379"
+	rediStackAddr = ":" + rediStackPort
+)
 
 var (
 	sentinelAddrs = []string{":" + sentinelPort1, ":" + sentinelPort2, ":" + sentinelPort3}
@@ -57,6 +65,8 @@ var cluster = &clusterScenario{
 	clients:   make(map[string]*redis.Client, 6),
 }
 
+var RECluster = false
+
 func registerProcess(port string, p *redisProcess) {
 	if processes == nil {
 		processes = make(map[string]*redisProcess)
@@ -71,47 +81,56 @@ var _ = BeforeSuite(func() {
 		redisAddr = ":" + redisPort
 	}
 	var err error
+	RECluster, _ = strconv.ParseBool(os.Getenv("RE_CLUSTER"))
+
+	if !RECluster {
 
-	redisMain, err = startRedis(redisPort)
-	Expect(err).NotTo(HaveOccurred())
+		redisMain, err = startRedis(redisPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	ringShard1, err = startRedis(ringShard1Port)
-	Expect(err).NotTo(HaveOccurred())
+		ringShard1, err = startRedis(ringShard1Port)
+		Expect(err).NotTo(HaveOccurred())
 
-	ringShard2, err = startRedis(ringShard2Port)
-	Expect(err).NotTo(HaveOccurred())
+		ringShard2, err = startRedis(ringShard2Port)
+		Expect(err).NotTo(HaveOccurred())
 
-	ringShard3, err = startRedis(ringShard3Port)
-	Expect(err).NotTo(HaveOccurred())
+		ringShard3, err = startRedis(ringShard3Port)
+		Expect(err).NotTo(HaveOccurred())
 
-	sentinelMaster, err = startRedis(sentinelMasterPort)
-	Expect(err).NotTo(HaveOccurred())
+		sentinelMaster, err = startRedis(sentinelMasterPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	sentinel1, err = startSentinel(sentinelPort1, sentinelName, sentinelMasterPort)
-	Expect(err).NotTo(HaveOccurred())
+		sentinel1, err = startSentinel(sentinelPort1, sentinelName, sentinelMasterPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	sentinel2, err = startSentinel(sentinelPort2, sentinelName, sentinelMasterPort)
-	Expect(err).NotTo(HaveOccurred())
+		sentinel2, err = startSentinel(sentinelPort2, sentinelName, sentinelMasterPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	sentinel3, err = startSentinel(sentinelPort3, sentinelName, sentinelMasterPort)
-	Expect(err).NotTo(HaveOccurred())
+		sentinel3, err = startSentinel(sentinelPort3, sentinelName, sentinelMasterPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	sentinelSlave1, err = startRedis(
-		sentinelSlave1Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
-	Expect(err).NotTo(HaveOccurred())
+		sentinelSlave1, err = startRedis(
+			sentinelSlave1Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	sentinelSlave2, err = startRedis(
-		sentinelSlave2Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
-	Expect(err).NotTo(HaveOccurred())
+		sentinelSlave2, err = startRedis(
+			sentinelSlave2Port, "--slaveof", "127.0.0.1", sentinelMasterPort)
+		Expect(err).NotTo(HaveOccurred())
 
-	Expect(startCluster(ctx, cluster)).NotTo(HaveOccurred())
+		Expect(startCluster(ctx, cluster)).NotTo(HaveOccurred())
+	} else {
+		redisPort = rediStackPort
+		redisAddr = rediStackAddr
+	}
 })
 
 var _ = AfterSuite(func() {
-	Expect(cluster.Close()).NotTo(HaveOccurred())
+	if !RECluster {
+		Expect(cluster.Close()).NotTo(HaveOccurred())
 
-	for _, p := range processes {
-		Expect(p.Close()).NotTo(HaveOccurred())
+		for _, p := range processes {
+			Expect(p.Close()).NotTo(HaveOccurred())
+		}
 	}
 	processes = nil
 })
@@ -124,6 +143,23 @@ func TestGinkgoSuite(t *testing.T) {
 //------------------------------------------------------------------------------
 
 func redisOptions() *redis.Options {
+	if RECluster {
+		return &redis.Options{
+			Addr: redisAddr,
+			DB:   0,
+
+			DialTimeout:           10 * time.Second,
+			ReadTimeout:           30 * time.Second,
+			WriteTimeout:          30 * time.Second,
+			ContextTimeoutEnabled: true,
+
+			MaxRetries: -1,
+			PoolSize:   10,
+
+			PoolTimeout:     30 * time.Second,
+			ConnMaxIdleTime: time.Minute,
+		}
+	}
 	return &redis.Options{
 		Addr: redisAddr,
 		DB:   15,
diff --git a/monitor_test.go b/monitor_test.go
new file mode 100644
index 000000000..91a733407
--- /dev/null
+++ b/monitor_test.go
@@ -0,0 +1,100 @@
+package redis_test
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"testing"
+
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+
+	"github.com/redis/go-redis/v9"
+)
+
+var _ = Describe("Monitor command", Label("monitor"), func() {
+	ctx := context.TODO()
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(&redis.Options{Addr: ":6379"})
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should monitor", Label("monitor"), func() {
+		ress := make(chan string)
+		client1 := redis.NewClient(&redis.Options{Addr: rediStackAddr})
+		mn := client1.Monitor(ctx, ress)
+		mn.Start()
+		// Wait for the Redis server to be in monitoring mode.
+		time.Sleep(100 * time.Millisecond)
+		client.Set(ctx, "foo", "bar", 0)
+		client.Set(ctx, "bar", "baz", 0)
+		client.Set(ctx, "bap", 8, 0)
+		client.Get(ctx, "bap")
+		lst := []string{}
+		for i := 0; i < 5; i++ {
+			s := <-ress
+			lst = append(lst, s)
+		}
+		mn.Stop()
+		Expect(lst[0]).To(ContainSubstring("OK"))
+		Expect(lst[1]).To(ContainSubstring(`"set" "foo" "bar"`))
+		Expect(lst[2]).To(ContainSubstring(`"set" "bar" "baz"`))
+		Expect(lst[3]).To(ContainSubstring(`"set" "bap" "8"`))
+	})
+})
+
+func TestMonitorCommand(t *testing.T) {
+	ctx := context.TODO()
+	client := redis.NewClient(&redis.Options{Addr: ":6379"})
+	if err := client.FlushDB(ctx).Err(); err != nil {
+		t.Fatalf("FlushDB failed: %v", err)
+	}
+
+	defer func() {
+		if err := client.Close(); err != nil {
+			t.Fatalf("Close failed: %v", err)
+		}
+	}()
+
+	ress := make(chan string, 10)                             // Buffer to prevent blocking
+	client1 := redis.NewClient(&redis.Options{Addr: ":6379"}) // Adjust the Addr field as necessary
+	mn := client1.Monitor(ctx, ress)
+	mn.Start()
+	// Wait for the Redis server to be in monitoring mode.
+	time.Sleep(100 * time.Millisecond)
+	client.Set(ctx, "foo", "bar", 0)
+	client.Set(ctx, "bar", "baz", 0)
+	client.Set(ctx, "bap", 8, 0)
+	client.Get(ctx, "bap")
+	mn.Stop()
+	var lst []string
+	for i := 0; i < 5; i++ {
+		s := <-ress
+		lst = append(lst, s)
+	}
+
+	// Assertions
+	if !containsSubstring(lst[0], "OK") {
+		t.Errorf("Expected lst[0] to contain 'OK', got %s", lst[0])
+	}
+	if !containsSubstring(lst[1], `"set" "foo" "bar"`) {
+		t.Errorf(`Expected lst[1] to contain '"set" "foo" "bar"', got %s`, lst[1])
+	}
+	if !containsSubstring(lst[2], `"set" "bar" "baz"`) {
+		t.Errorf(`Expected lst[2] to contain '"set" "bar" "baz"', got %s`, lst[2])
+	}
+	if !containsSubstring(lst[3], `"set" "bap" "8"`) {
+		t.Errorf(`Expected lst[3] to contain '"set" "bap" "8"', got %s`, lst[3])
+	}
+}
+
+func containsSubstring(s, substr string) bool {
+	return strings.Contains(s, substr)
+}
diff --git a/options.go b/options.go
index bb4816b27..6ed693a0b 100644
--- a/options.go
+++ b/options.go
@@ -61,6 +61,12 @@ type Options struct {
 	// before reconnecting. It should return the current username and password.
 	CredentialsProvider func() (username string, password string)
 
+	// CredentialsProviderContext is an enhanced parameter of CredentialsProvider,
+	// done to maintain API compatibility. In the future,
+	// there might be a merge between CredentialsProviderContext and CredentialsProvider.
+	// There will be a conflict between them; if CredentialsProviderContext exists, we will ignore CredentialsProvider.
+	CredentialsProviderContext func(ctx context.Context) (username string, password string, err error)
+
 	// Database to be selected after connecting to the server.
 	DB int
 
@@ -98,8 +104,10 @@ type Options struct {
 	// Note that FIFO has slightly higher overhead compared to LIFO,
 	// but it helps closing idle connections faster reducing the pool size.
 	PoolFIFO bool
-	// Maximum number of socket connections.
+	// Base number of socket connections.
 	// Default is 10 connections per every available CPU as reported by runtime.GOMAXPROCS.
+	// If there is not enough connections in the pool, new connections will be allocated in excess of PoolSize,
+	// you can limit it through MaxActiveConns
 	PoolSize int
 	// Amount of time client waits for connection if all connections
 	// are busy before returning an error.
@@ -112,6 +120,9 @@ type Options struct {
 	// Maximum number of idle connections.
 	// Default is 0. the idle connections are not closed by default.
 	MaxIdleConns int
+	// Maximum number of connections allocated by the pool at a given time.
+	// When zero, there is no limit on the number of connections in the pool.
+	MaxActiveConns int
 	// ConnMaxIdleTime is the maximum amount of time a connection may be idle.
 	// Should be less than server's timeout.
 	//
@@ -136,6 +147,12 @@ type Options struct {
 
 	// Enables read only queries on slave/follower nodes.
 	readOnly bool
+
+	// Disable set-lib on connect. Default is false.
+	DisableIndentity bool
+
+	// Add suffix to client name. Default is empty.
+	IdentitySuffix string
 }
 
 func (opt *Options) init() {
@@ -224,7 +241,7 @@ func NewDialer(opt *Options) func(context.Context, string, string) (net.Conn, er
 	}
 }
 
-// ParseURL parses an URL into Options that can be used to connect to Redis.
+// ParseURL parses a URL into Options that can be used to connect to Redis.
 // Scheme is required.
 // There are two connection types: by tcp socket and by unix socket.
 // Tcp connection:
@@ -239,12 +256,12 @@ func NewDialer(opt *Options) func(context.Context, string, string) (net.Conn, er
 //   - field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
 //   - only scalar type fields are supported (bool, int, time.Duration)
 //   - for time.Duration fields, values must be a valid input for time.ParseDuration();
-//     additionally a plain integer as value (i.e. without unit) is intepreted as seconds
+//     additionally a plain integer as value (i.e. without unit) is interpreted as seconds
 //   - to disable a duration field, use value less than or equal to 0; to use the default
 //     value, leave the value blank or remove the parameter
 //   - only the last value is interpreted if a parameter is given multiple times
 //   - fields "network", "addr", "username" and "password" can only be set using other
-//     URL attributes (scheme, host, userinfo, resp.), query paremeters using these
+//     URL attributes (scheme, host, userinfo, resp.), query parameters using these
 //     names will be treated as unknown parameters
 //   - unknown parameter names will result in an error
 //
@@ -453,6 +470,7 @@ func setupConnParams(u *url.URL, o *Options) (*Options, error) {
 	o.PoolTimeout = q.duration("pool_timeout")
 	o.MinIdleConns = q.int("min_idle_conns")
 	o.MaxIdleConns = q.int("max_idle_conns")
+	o.MaxActiveConns = q.int("max_active_conns")
 	if q.has("conn_max_idle_time") {
 		o.ConnMaxIdleTime = q.duration("conn_max_idle_time")
 	} else {
@@ -499,6 +517,7 @@ func newConnPool(
 		PoolTimeout:     opt.PoolTimeout,
 		MinIdleConns:    opt.MinIdleConns,
 		MaxIdleConns:    opt.MaxIdleConns,
+		MaxActiveConns:  opt.MaxActiveConns,
 		ConnMaxIdleTime: opt.ConnMaxIdleTime,
 		ConnMaxLifetime: opt.ConnMaxLifetime,
 	})
diff --git a/options_test.go b/options_test.go
index fa9ac6c9e..1db36fdb4 100644
--- a/options_test.go
+++ b/options_test.go
@@ -1,5 +1,4 @@
 //go:build go1.7
-// +build go1.7
 
 package redis
 
diff --git a/cluster.go b/osscluster.go
similarity index 95%
rename from cluster.go
rename to osscluster.go
index 941838dd0..e28cb1e39 100644
--- a/cluster.go
+++ b/osscluster.go
@@ -62,9 +62,11 @@ type ClusterOptions struct {
 
 	OnConnect func(ctx context.Context, cn *Conn) error
 
-	Protocol int
-	Username string
-	Password string
+	Protocol                   int
+	Username                   string
+	Password                   string
+	CredentialsProvider        func() (username string, password string)
+	CredentialsProviderContext func(ctx context.Context) (username string, password string, err error)
 
 	MaxRetries      int
 	MinRetryBackoff time.Duration
@@ -80,10 +82,14 @@ type ClusterOptions struct {
 	PoolTimeout     time.Duration
 	MinIdleConns    int
 	MaxIdleConns    int
+	MaxActiveConns  int // applies per cluster node and not for the whole cluster
 	ConnMaxIdleTime time.Duration
 	ConnMaxLifetime time.Duration
 
-	TLSConfig *tls.Config
+	TLSConfig        *tls.Config
+	DisableIndentity bool // Disable set-lib on connect. Default is false.
+
+	IdentitySuffix string // Add suffix to client name. Default is empty.
 }
 
 func (opt *ClusterOptions) init() {
@@ -152,12 +158,12 @@ func (opt *ClusterOptions) init() {
 //   - field names are mapped using snake-case conversion: to set MaxRetries, use max_retries
 //   - only scalar type fields are supported (bool, int, time.Duration)
 //   - for time.Duration fields, values must be a valid input for time.ParseDuration();
-//     additionally a plain integer as value (i.e. without unit) is intepreted as seconds
+//     additionally a plain integer as value (i.e. without unit) is interpreted as seconds
 //   - to disable a duration field, use value less than or equal to 0; to use the default
 //     value, leave the value blank or remove the parameter
 //   - only the last value is interpreted if a parameter is given multiple times
 //   - fields "network", "addr", "username" and "password" can only be set using other
-//     URL attributes (scheme, host, userinfo, resp.), query paremeters using these
+//     URL attributes (scheme, host, userinfo, resp.), query parameters using these
 //     names will be treated as unknown parameters
 //   - unknown parameter names will result in an error
 //
@@ -232,6 +238,8 @@ func setupClusterQueryParams(u *url.URL, o *ClusterOptions) (*ClusterOptions, er
 	o.PoolFIFO = q.bool("pool_fifo")
 	o.PoolSize = q.int("pool_size")
 	o.MinIdleConns = q.int("min_idle_conns")
+	o.MaxIdleConns = q.int("max_idle_conns")
+	o.MaxActiveConns = q.int("max_active_conns")
 	o.PoolTimeout = q.duration("pool_timeout")
 	o.ConnMaxLifetime = q.duration("conn_max_lifetime")
 	o.ConnMaxIdleTime = q.duration("conn_max_idle_time")
@@ -265,27 +273,32 @@ func (opt *ClusterOptions) clientOptions() *Options {
 		Dialer:     opt.Dialer,
 		OnConnect:  opt.OnConnect,
 
-		Protocol: opt.Protocol,
-		Username: opt.Username,
-		Password: opt.Password,
+		Protocol:                   opt.Protocol,
+		Username:                   opt.Username,
+		Password:                   opt.Password,
+		CredentialsProvider:        opt.CredentialsProvider,
+		CredentialsProviderContext: opt.CredentialsProviderContext,
 
 		MaxRetries:      opt.MaxRetries,
 		MinRetryBackoff: opt.MinRetryBackoff,
 		MaxRetryBackoff: opt.MaxRetryBackoff,
 
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
-
-		PoolFIFO:        opt.PoolFIFO,
-		PoolSize:        opt.PoolSize,
-		PoolTimeout:     opt.PoolTimeout,
-		MinIdleConns:    opt.MinIdleConns,
-		MaxIdleConns:    opt.MaxIdleConns,
-		ConnMaxIdleTime: opt.ConnMaxIdleTime,
-		ConnMaxLifetime: opt.ConnMaxLifetime,
-
-		TLSConfig: opt.TLSConfig,
+		DialTimeout:           opt.DialTimeout,
+		ReadTimeout:           opt.ReadTimeout,
+		WriteTimeout:          opt.WriteTimeout,
+		ContextTimeoutEnabled: opt.ContextTimeoutEnabled,
+
+		PoolFIFO:         opt.PoolFIFO,
+		PoolSize:         opt.PoolSize,
+		PoolTimeout:      opt.PoolTimeout,
+		MinIdleConns:     opt.MinIdleConns,
+		MaxIdleConns:     opt.MaxIdleConns,
+		MaxActiveConns:   opt.MaxActiveConns,
+		ConnMaxIdleTime:  opt.ConnMaxIdleTime,
+		ConnMaxLifetime:  opt.ConnMaxLifetime,
+		DisableIndentity: opt.DisableIndentity,
+		IdentitySuffix:   opt.IdentitySuffix,
+		TLSConfig:        opt.TLSConfig,
 		// If ClusterSlots is populated, then we probably have an artificial
 		// cluster whose nodes are not in clustering mode (otherwise there isn't
 		// much use for ClusterSlots config).  This means we cannot execute the
@@ -901,7 +914,6 @@ func (c *ClusterClient) Process(ctx context.Context, cmd Cmder) error {
 }
 
 func (c *ClusterClient) process(ctx context.Context, cmd Cmder) error {
-	cmdInfo := c.cmdInfo(ctx, cmd.Name())
 	slot := c.cmdSlot(ctx, cmd)
 	var node *clusterNode
 	var ask bool
@@ -915,7 +927,7 @@ func (c *ClusterClient) process(ctx context.Context, cmd Cmder) error {
 
 		if node == nil {
 			var err error
-			node, err = c.cmdNode(ctx, cmdInfo, slot)
+			node, err = c.cmdNode(ctx, cmd.Name(), slot)
 			if err != nil {
 				return err
 			}
@@ -1285,6 +1297,7 @@ func (c *ClusterClient) processPipelineNode(
 	_ = node.Client.withProcessPipelineHook(ctx, cmds, func(ctx context.Context, cmds []Cmder) error {
 		cn, err := node.Client.getConn(ctx)
 		if err != nil {
+			node.MarkAsFailing()
 			_ = c.mapCmdsByNode(ctx, failedCmds, cmds)
 			setCmdsErr(cmds, err)
 			return err
@@ -1306,6 +1319,9 @@ func (c *ClusterClient) processPipelineNodeConn(
 	if err := cn.WithWriter(c.context(ctx), c.opt.WriteTimeout, func(wr *proto.Writer) error {
 		return writeCmds(wr, cmds)
 	}); err != nil {
+		if isBadConn(err, false, node.Client.getAddr()) {
+			node.MarkAsFailing()
+		}
 		if shouldRetry(err, true) {
 			_ = c.mapCmdsByNode(ctx, failedCmds, cmds)
 		}
@@ -1337,7 +1353,7 @@ func (c *ClusterClient) pipelineReadCmds(
 			continue
 		}
 
-		if c.opt.ReadOnly {
+		if c.opt.ReadOnly && isBadConn(err, false, node.Client.getAddr()) {
 			node.MarkAsFailing()
 		}
 
@@ -1777,8 +1793,7 @@ func (c *ClusterClient) cmdSlot(ctx context.Context, cmd Cmder) int {
 		return args[2].(int)
 	}
 
-	cmdInfo := c.cmdInfo(ctx, cmd.Name())
-	return cmdSlot(cmd, cmdFirstKeyPos(cmd, cmdInfo))
+	return cmdSlot(cmd, cmdFirstKeyPos(cmd))
 }
 
 func cmdSlot(cmd Cmder, pos int) int {
@@ -1791,7 +1806,7 @@ func cmdSlot(cmd Cmder, pos int) int {
 
 func (c *ClusterClient) cmdNode(
 	ctx context.Context,
-	cmdInfo *CommandInfo,
+	cmdName string,
 	slot int,
 ) (*clusterNode, error) {
 	state, err := c.state.Get(ctx)
@@ -1799,8 +1814,11 @@ func (c *ClusterClient) cmdNode(
 		return nil, err
 	}
 
-	if c.opt.ReadOnly && cmdInfo != nil && cmdInfo.ReadOnly {
-		return c.slotReadOnlyNode(state, slot)
+	if c.opt.ReadOnly {
+		cmdInfo := c.cmdInfo(ctx, cmdName)
+		if cmdInfo != nil && cmdInfo.ReadOnly {
+			return c.slotReadOnlyNode(state, slot)
+		}
 	}
 	return state.slotMasterNode(slot)
 }
diff --git a/osscluster_commands.go b/osscluster_commands.go
new file mode 100644
index 000000000..b13f8e7e9
--- /dev/null
+++ b/osscluster_commands.go
@@ -0,0 +1,109 @@
+package redis
+
+import (
+	"context"
+	"sync"
+	"sync/atomic"
+)
+
+func (c *ClusterClient) DBSize(ctx context.Context) *IntCmd {
+	cmd := NewIntCmd(ctx, "dbsize")
+	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
+		var size int64
+		err := c.ForEachMaster(ctx, func(ctx context.Context, master *Client) error {
+			n, err := master.DBSize(ctx).Result()
+			if err != nil {
+				return err
+			}
+			atomic.AddInt64(&size, n)
+			return nil
+		})
+		if err != nil {
+			cmd.SetErr(err)
+		} else {
+			cmd.val = size
+		}
+		return nil
+	})
+	return cmd
+}
+
+func (c *ClusterClient) ScriptLoad(ctx context.Context, script string) *StringCmd {
+	cmd := NewStringCmd(ctx, "script", "load", script)
+	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
+		var mu sync.Mutex
+		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
+			val, err := shard.ScriptLoad(ctx, script).Result()
+			if err != nil {
+				return err
+			}
+
+			mu.Lock()
+			if cmd.Val() == "" {
+				cmd.val = val
+			}
+			mu.Unlock()
+
+			return nil
+		})
+		if err != nil {
+			cmd.SetErr(err)
+		}
+		return nil
+	})
+	return cmd
+}
+
+func (c *ClusterClient) ScriptFlush(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "script", "flush")
+	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
+		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
+			return shard.ScriptFlush(ctx).Err()
+		})
+		if err != nil {
+			cmd.SetErr(err)
+		}
+		return nil
+	})
+	return cmd
+}
+
+func (c *ClusterClient) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
+	args := make([]interface{}, 2+len(hashes))
+	args[0] = "script"
+	args[1] = "exists"
+	for i, hash := range hashes {
+		args[2+i] = hash
+	}
+	cmd := NewBoolSliceCmd(ctx, args...)
+
+	result := make([]bool, len(hashes))
+	for i := range result {
+		result[i] = true
+	}
+
+	_ = c.withProcessHook(ctx, cmd, func(ctx context.Context, _ Cmder) error {
+		var mu sync.Mutex
+		err := c.ForEachShard(ctx, func(ctx context.Context, shard *Client) error {
+			val, err := shard.ScriptExists(ctx, hashes...).Result()
+			if err != nil {
+				return err
+			}
+
+			mu.Lock()
+			for i, v := range val {
+				result[i] = result[i] && v
+			}
+			mu.Unlock()
+
+			return nil
+		})
+		if err != nil {
+			cmd.SetErr(err)
+		} else {
+			cmd.val = result
+		}
+		return nil
+	})
+	return cmd
+}
diff --git a/cluster_test.go b/osscluster_test.go
similarity index 99%
rename from cluster_test.go
rename to osscluster_test.go
index d3b4474a2..3d2f80711 100644
--- a/cluster_test.go
+++ b/osscluster_test.go
@@ -13,6 +13,7 @@ import (
 
 	. "github.com/bsm/ginkgo/v2"
 	. "github.com/bsm/gomega"
+
 	"github.com/redis/go-redis/v9"
 	"github.com/redis/go-redis/v9/internal/hashtag"
 )
@@ -1457,7 +1458,7 @@ var _ = Describe("ClusterClient timeout", func() {
 })
 
 var _ = Describe("ClusterClient ParseURL", func() {
-	var cases = []struct {
+	cases := []struct {
 		test string
 		url  string
 		o    *redis.ClusterOptions // expected value
diff --git a/package.json b/package.json
deleted file mode 100644
index e26e29141..000000000
--- a/package.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "name": "redis",
-  "version": "9.0.5",
-  "main": "index.js",
-  "repository": "git@github.com:redis/go-redis.git",
-  "author": "Vladimir Mihailenco <vladimir.webdev@gmail.com>",
-  "license": "BSD-2-clause"
-}
diff --git a/pipeline_test.go b/pipeline_test.go
index 45b0a1be7..7f7344729 100644
--- a/pipeline_test.go
+++ b/pipeline_test.go
@@ -71,7 +71,7 @@ var _ = Describe("pipelining", func() {
 			Expect(cmds).To(HaveLen(1))
 		})
 
-		It("handles large pipelines", func() {
+		It("handles large pipelines", Label("NonRedisEnterprise"), func() {
 			for callCount := 1; callCount < 16; callCount++ {
 				for i := 1; i <= callCount; i++ {
 					pipe.SetNX(ctx, strconv.Itoa(i)+"_key", strconv.Itoa(i)+"_value", 0)
diff --git a/probabilistic.go b/probabilistic.go
new file mode 100644
index 000000000..5d5cd1a62
--- /dev/null
+++ b/probabilistic.go
@@ -0,0 +1,1429 @@
+package redis
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/redis/go-redis/v9/internal/proto"
+)
+
+type ProbabilisticCmdable interface {
+	BFAdd(ctx context.Context, key string, element interface{}) *BoolCmd
+	BFCard(ctx context.Context, key string) *IntCmd
+	BFExists(ctx context.Context, key string, element interface{}) *BoolCmd
+	BFInfo(ctx context.Context, key string) *BFInfoCmd
+	BFInfoArg(ctx context.Context, key, option string) *BFInfoCmd
+	BFInfoCapacity(ctx context.Context, key string) *BFInfoCmd
+	BFInfoSize(ctx context.Context, key string) *BFInfoCmd
+	BFInfoFilters(ctx context.Context, key string) *BFInfoCmd
+	BFInfoItems(ctx context.Context, key string) *BFInfoCmd
+	BFInfoExpansion(ctx context.Context, key string) *BFInfoCmd
+	BFInsert(ctx context.Context, key string, options *BFInsertOptions, elements ...interface{}) *BoolSliceCmd
+	BFMAdd(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
+	BFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
+	BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd
+	BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *StatusCmd
+	BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd
+	BFReserveWithArgs(ctx context.Context, key string, options *BFReserveOptions) *StatusCmd
+	BFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd
+	BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd
+
+	CFAdd(ctx context.Context, key string, element interface{}) *BoolCmd
+	CFAddNX(ctx context.Context, key string, element interface{}) *BoolCmd
+	CFCount(ctx context.Context, key string, element interface{}) *IntCmd
+	CFDel(ctx context.Context, key string, element interface{}) *BoolCmd
+	CFExists(ctx context.Context, key string, element interface{}) *BoolCmd
+	CFInfo(ctx context.Context, key string) *CFInfoCmd
+	CFInsert(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *BoolSliceCmd
+	CFInsertNX(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *IntSliceCmd
+	CFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
+	CFReserve(ctx context.Context, key string, capacity int64) *StatusCmd
+	CFReserveWithArgs(ctx context.Context, key string, options *CFReserveOptions) *StatusCmd
+	CFReserveExpansion(ctx context.Context, key string, capacity int64, expansion int64) *StatusCmd
+	CFReserveBucketSize(ctx context.Context, key string, capacity int64, bucketsize int64) *StatusCmd
+	CFReserveMaxIterations(ctx context.Context, key string, capacity int64, maxiterations int64) *StatusCmd
+	CFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd
+	CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd
+
+	CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd
+	CMSInfo(ctx context.Context, key string) *CMSInfoCmd
+	CMSInitByDim(ctx context.Context, key string, width, height int64) *StatusCmd
+	CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *StatusCmd
+	CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *StatusCmd
+	CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *StatusCmd
+	CMSQuery(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd
+
+	TopKAdd(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd
+	TopKCount(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd
+	TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd
+	TopKInfo(ctx context.Context, key string) *TopKInfoCmd
+	TopKList(ctx context.Context, key string) *StringSliceCmd
+	TopKListWithCount(ctx context.Context, key string) *MapStringIntCmd
+	TopKQuery(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd
+	TopKReserve(ctx context.Context, key string, k int64) *StatusCmd
+	TopKReserveWithOptions(ctx context.Context, key string, k int64, width, depth int64, decay float64) *StatusCmd
+
+	TDigestAdd(ctx context.Context, key string, elements ...float64) *StatusCmd
+	TDigestByRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd
+	TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd
+	TDigestCDF(ctx context.Context, key string, elements ...float64) *FloatSliceCmd
+	TDigestCreate(ctx context.Context, key string) *StatusCmd
+	TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *StatusCmd
+	TDigestInfo(ctx context.Context, key string) *TDigestInfoCmd
+	TDigestMax(ctx context.Context, key string) *FloatCmd
+	TDigestMin(ctx context.Context, key string) *FloatCmd
+	TDigestMerge(ctx context.Context, destKey string, options *TDigestMergeOptions, sourceKeys ...string) *StatusCmd
+	TDigestQuantile(ctx context.Context, key string, elements ...float64) *FloatSliceCmd
+	TDigestRank(ctx context.Context, key string, values ...float64) *IntSliceCmd
+	TDigestReset(ctx context.Context, key string) *StatusCmd
+	TDigestRevRank(ctx context.Context, key string, values ...float64) *IntSliceCmd
+	TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *FloatCmd
+}
+
+type BFInsertOptions struct {
+	Capacity   int64
+	Error      float64
+	Expansion  int64
+	NonScaling bool
+	NoCreate   bool
+}
+
+type BFReserveOptions struct {
+	Capacity   int64
+	Error      float64
+	Expansion  int64
+	NonScaling bool
+}
+
+type CFReserveOptions struct {
+	Capacity      int64
+	BucketSize    int64
+	MaxIterations int64
+	Expansion     int64
+}
+
+type CFInsertOptions struct {
+	Capacity int64
+	NoCreate bool
+}
+
+// -------------------------------------------
+// Bloom filter commands
+//-------------------------------------------
+
+// BFReserve creates an empty Bloom filter with a single sub-filter
+// for the initial specified capacity and with an upper bound error_rate.
+// For more information - https://redis.io/commands/bf.reserve/
+func (c cmdable) BFReserve(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd {
+	args := []interface{}{"BF.RESERVE", key, errorRate, capacity}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFReserveExpansion creates an empty Bloom filter with a single sub-filter
+// for the initial specified capacity and with an upper bound error_rate.
+// This function also allows for specifying an expansion rate for the filter.
+// For more information - https://redis.io/commands/bf.reserve/
+func (c cmdable) BFReserveExpansion(ctx context.Context, key string, errorRate float64, capacity, expansion int64) *StatusCmd {
+	args := []interface{}{"BF.RESERVE", key, errorRate, capacity, "EXPANSION", expansion}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFReserveNonScaling creates an empty Bloom filter with a single sub-filter
+// for the initial specified capacity and with an upper bound error_rate.
+// This function also allows for specifying that the filter should not scale.
+// For more information - https://redis.io/commands/bf.reserve/
+func (c cmdable) BFReserveNonScaling(ctx context.Context, key string, errorRate float64, capacity int64) *StatusCmd {
+	args := []interface{}{"BF.RESERVE", key, errorRate, capacity, "NONSCALING"}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFReserveWithArgs creates an empty Bloom filter with a single sub-filter
+// for the initial specified capacity and with an upper bound error_rate.
+// This function also allows for specifying additional options such as expansion rate and non-scaling behavior.
+// For more information - https://redis.io/commands/bf.reserve/
+func (c cmdable) BFReserveWithArgs(ctx context.Context, key string, options *BFReserveOptions) *StatusCmd {
+	args := []interface{}{"BF.RESERVE", key}
+	if options != nil {
+		args = append(args, options.Error, options.Capacity)
+		if options.Expansion != 0 {
+			args = append(args, "EXPANSION", options.Expansion)
+		}
+		if options.NonScaling {
+			args = append(args, "NONSCALING")
+		}
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFAdd adds an item to a Bloom filter.
+// For more information - https://redis.io/commands/bf.add/
+func (c cmdable) BFAdd(ctx context.Context, key string, element interface{}) *BoolCmd {
+	args := []interface{}{"BF.ADD", key, element}
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFCard returns the cardinality of a Bloom filter -
+// number of items that were added to a Bloom filter and detected as unique
+// (items that caused at least one bit to be set in at least one sub-filter).
+// For more information - https://redis.io/commands/bf.card/
+func (c cmdable) BFCard(ctx context.Context, key string) *IntCmd {
+	args := []interface{}{"BF.CARD", key}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFExists determines whether a given item was added to a Bloom filter.
+// For more information - https://redis.io/commands/bf.exists/
+func (c cmdable) BFExists(ctx context.Context, key string, element interface{}) *BoolCmd {
+	args := []interface{}{"BF.EXISTS", key, element}
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFLoadChunk restores a Bloom filter previously saved using BF.SCANDUMP.
+// For more information - https://redis.io/commands/bf.loadchunk/
+func (c cmdable) BFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd {
+	args := []interface{}{"BF.LOADCHUNK", key, iterator, data}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// Begins an incremental save of the Bloom filter.
+// This command is useful for large Bloom filters that cannot fit into the DUMP and RESTORE model.
+// For more information - https://redis.io/commands/bf.scandump/
+func (c cmdable) BFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd {
+	args := []interface{}{"BF.SCANDUMP", key, iterator}
+	cmd := newScanDumpCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type ScanDump struct {
+	Iter int64
+	Data string
+}
+
+type ScanDumpCmd struct {
+	baseCmd
+
+	val ScanDump
+}
+
+func newScanDumpCmd(ctx context.Context, args ...interface{}) *ScanDumpCmd {
+	return &ScanDumpCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *ScanDumpCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *ScanDumpCmd) SetVal(val ScanDump) {
+	cmd.val = val
+}
+
+func (cmd *ScanDumpCmd) Result() (ScanDump, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *ScanDumpCmd) Val() ScanDump {
+	return cmd.val
+}
+
+func (cmd *ScanDumpCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+	cmd.val = ScanDump{}
+	for i := 0; i < n; i++ {
+		iter, err := rd.ReadInt()
+		if err != nil {
+			return err
+		}
+		data, err := rd.ReadString()
+		if err != nil {
+			return err
+		}
+		cmd.val.Data = data
+		cmd.val.Iter = iter
+
+	}
+
+	return nil
+}
+
+// Returns information about a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfo(ctx context.Context, key string) *BFInfoCmd {
+	args := []interface{}{"BF.INFO", key}
+	cmd := NewBFInfoCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type BFInfo struct {
+	Capacity      int64
+	Size          int64
+	Filters       int64
+	ItemsInserted int64
+	ExpansionRate int64
+}
+
+type BFInfoCmd struct {
+	baseCmd
+
+	val BFInfo
+}
+
+func NewBFInfoCmd(ctx context.Context, args ...interface{}) *BFInfoCmd {
+	return &BFInfoCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *BFInfoCmd) SetVal(val BFInfo) {
+	cmd.val = val
+}
+
+func (cmd *BFInfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *BFInfoCmd) Val() BFInfo {
+	return cmd.val
+}
+
+func (cmd *BFInfoCmd) Result() (BFInfo, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *BFInfoCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+
+	var key string
+	var result BFInfo
+	for f := 0; f < n; f++ {
+		key, err = rd.ReadString()
+		if err != nil {
+			return err
+		}
+
+		switch key {
+		case "Capacity":
+			result.Capacity, err = rd.ReadInt()
+		case "Size":
+			result.Size, err = rd.ReadInt()
+		case "Number of filters":
+			result.Filters, err = rd.ReadInt()
+		case "Number of items inserted":
+			result.ItemsInserted, err = rd.ReadInt()
+		case "Expansion rate":
+			result.ExpansionRate, err = rd.ReadInt()
+		default:
+			return fmt.Errorf("redis: BLOOM.INFO unexpected key %s", key)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd.val = result
+	return nil
+}
+
+// BFInfoCapacity returns information about the capacity of a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfoCapacity(ctx context.Context, key string) *BFInfoCmd {
+	return c.BFInfoArg(ctx, key, "CAPACITY")
+}
+
+// BFInfoSize returns information about the size of a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfoSize(ctx context.Context, key string) *BFInfoCmd {
+	return c.BFInfoArg(ctx, key, "SIZE")
+}
+
+// BFInfoFilters returns information about the filters of a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfoFilters(ctx context.Context, key string) *BFInfoCmd {
+	return c.BFInfoArg(ctx, key, "FILTERS")
+}
+
+// BFInfoItems returns information about the items of a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfoItems(ctx context.Context, key string) *BFInfoCmd {
+	return c.BFInfoArg(ctx, key, "ITEMS")
+}
+
+// BFInfoExpansion returns information about the expansion rate of a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfoExpansion(ctx context.Context, key string) *BFInfoCmd {
+	return c.BFInfoArg(ctx, key, "EXPANSION")
+}
+
+// BFInfoArg returns information about a specific option of a Bloom filter.
+// For more information - https://redis.io/commands/bf.info/
+func (c cmdable) BFInfoArg(ctx context.Context, key, option string) *BFInfoCmd {
+	args := []interface{}{"BF.INFO", key, option}
+	cmd := NewBFInfoCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFInsert inserts elements into a Bloom filter.
+// This function also allows for specifying additional options such as:
+// capacity, error rate, expansion rate, and non-scaling behavior.
+// For more information - https://redis.io/commands/bf.insert/
+func (c cmdable) BFInsert(ctx context.Context, key string, options *BFInsertOptions, elements ...interface{}) *BoolSliceCmd {
+	args := []interface{}{"BF.INSERT", key}
+	if options != nil {
+		if options.Capacity != 0 {
+			args = append(args, "CAPACITY", options.Capacity)
+		}
+		if options.Error != 0 {
+			args = append(args, "ERROR", options.Error)
+		}
+		if options.Expansion != 0 {
+			args = append(args, "EXPANSION", options.Expansion)
+		}
+		if options.NoCreate {
+			args = append(args, "NOCREATE")
+		}
+		if options.NonScaling {
+			args = append(args, "NONSCALING")
+		}
+	}
+	args = append(args, "ITEMS")
+	args = append(args, elements...)
+
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFMAdd adds multiple elements to a Bloom filter.
+// Returns an array of booleans indicating whether each element was added to the filter or not.
+// For more information - https://redis.io/commands/bf.madd/
+func (c cmdable) BFMAdd(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
+	args := []interface{}{"BF.MADD", key}
+	args = append(args, elements...)
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BFMExists check if multiple elements exist in a Bloom filter.
+// Returns an array of booleans indicating whether each element exists in the filter or not.
+// For more information - https://redis.io/commands/bf.mexists/
+func (c cmdable) BFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
+	args := []interface{}{"BF.MEXISTS", key}
+	args = append(args, elements...)
+
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// -------------------------------------------
+// Cuckoo filter commands
+//-------------------------------------------
+
+// CFReserve creates an empty Cuckoo filter with the specified capacity.
+// For more information - https://redis.io/commands/cf.reserve/
+func (c cmdable) CFReserve(ctx context.Context, key string, capacity int64) *StatusCmd {
+	args := []interface{}{"CF.RESERVE", key, capacity}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFReserveExpansion creates an empty Cuckoo filter with the specified capacity and expansion rate.
+// For more information - https://redis.io/commands/cf.reserve/
+func (c cmdable) CFReserveExpansion(ctx context.Context, key string, capacity int64, expansion int64) *StatusCmd {
+	args := []interface{}{"CF.RESERVE", key, capacity, "EXPANSION", expansion}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFReserveBucketSize creates an empty Cuckoo filter with the specified capacity and bucket size.
+// For more information - https://redis.io/commands/cf.reserve/
+func (c cmdable) CFReserveBucketSize(ctx context.Context, key string, capacity int64, bucketsize int64) *StatusCmd {
+	args := []interface{}{"CF.RESERVE", key, capacity, "BUCKETSIZE", bucketsize}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFReserveMaxIterations creates an empty Cuckoo filter with the specified capacity and maximum number of iterations.
+// For more information - https://redis.io/commands/cf.reserve/
+func (c cmdable) CFReserveMaxIterations(ctx context.Context, key string, capacity int64, maxiterations int64) *StatusCmd {
+	args := []interface{}{"CF.RESERVE", key, capacity, "MAXITERATIONS", maxiterations}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFReserveWithArgs creates an empty Cuckoo filter with the specified options.
+// This function allows for specifying additional options such as bucket size and maximum number of iterations.
+// For more information - https://redis.io/commands/cf.reserve/
+func (c cmdable) CFReserveWithArgs(ctx context.Context, key string, options *CFReserveOptions) *StatusCmd {
+	args := []interface{}{"CF.RESERVE", key, options.Capacity}
+	if options.BucketSize != 0 {
+		args = append(args, "BUCKETSIZE", options.BucketSize)
+	}
+	if options.MaxIterations != 0 {
+		args = append(args, "MAXITERATIONS", options.MaxIterations)
+	}
+	if options.Expansion != 0 {
+		args = append(args, "EXPANSION", options.Expansion)
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFAdd adds an element to a Cuckoo filter.
+// Returns true if the element was added to the filter or false if it already exists in the filter.
+// For more information - https://redis.io/commands/cf.add/
+func (c cmdable) CFAdd(ctx context.Context, key string, element interface{}) *BoolCmd {
+	args := []interface{}{"CF.ADD", key, element}
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFAddNX adds an element to a Cuckoo filter only if it does not already exist in the filter.
+// Returns true if the element was added to the filter or false if it already exists in the filter.
+// For more information - https://redis.io/commands/cf.addnx/
+func (c cmdable) CFAddNX(ctx context.Context, key string, element interface{}) *BoolCmd {
+	args := []interface{}{"CF.ADDNX", key, element}
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFCount returns an estimate of the number of times an element may be in a Cuckoo Filter.
+// For more information - https://redis.io/commands/cf.count/
+func (c cmdable) CFCount(ctx context.Context, key string, element interface{}) *IntCmd {
+	args := []interface{}{"CF.COUNT", key, element}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFDel deletes an item once from the cuckoo filter.
+// For more information - https://redis.io/commands/cf.del/
+func (c cmdable) CFDel(ctx context.Context, key string, element interface{}) *BoolCmd {
+	args := []interface{}{"CF.DEL", key, element}
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFExists determines whether an item may exist in the Cuckoo Filter or not.
+// For more information - https://redis.io/commands/cf.exists/
+func (c cmdable) CFExists(ctx context.Context, key string, element interface{}) *BoolCmd {
+	args := []interface{}{"CF.EXISTS", key, element}
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFLoadChunk restores a filter previously saved using SCANDUMP.
+// For more information - https://redis.io/commands/cf.loadchunk/
+func (c cmdable) CFLoadChunk(ctx context.Context, key string, iterator int64, data interface{}) *StatusCmd {
+	args := []interface{}{"CF.LOADCHUNK", key, iterator, data}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFScanDump begins an incremental save of the cuckoo filter.
+// For more information - https://redis.io/commands/cf.scandump/
+func (c cmdable) CFScanDump(ctx context.Context, key string, iterator int64) *ScanDumpCmd {
+	args := []interface{}{"CF.SCANDUMP", key, iterator}
+	cmd := newScanDumpCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type CFInfo struct {
+	Size             int64
+	NumBuckets       int64
+	NumFilters       int64
+	NumItemsInserted int64
+	NumItemsDeleted  int64
+	BucketSize       int64
+	ExpansionRate    int64
+	MaxIteration     int64
+}
+
+type CFInfoCmd struct {
+	baseCmd
+
+	val CFInfo
+}
+
+func NewCFInfoCmd(ctx context.Context, args ...interface{}) *CFInfoCmd {
+	return &CFInfoCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *CFInfoCmd) SetVal(val CFInfo) {
+	cmd.val = val
+}
+
+func (cmd *CFInfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *CFInfoCmd) Val() CFInfo {
+	return cmd.val
+}
+
+func (cmd *CFInfoCmd) Result() (CFInfo, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *CFInfoCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+
+	var key string
+	var result CFInfo
+	for f := 0; f < n; f++ {
+		key, err = rd.ReadString()
+		if err != nil {
+			return err
+		}
+
+		switch key {
+		case "Size":
+			result.Size, err = rd.ReadInt()
+		case "Number of buckets":
+			result.NumBuckets, err = rd.ReadInt()
+		case "Number of filters":
+			result.NumFilters, err = rd.ReadInt()
+		case "Number of items inserted":
+			result.NumItemsInserted, err = rd.ReadInt()
+		case "Number of items deleted":
+			result.NumItemsDeleted, err = rd.ReadInt()
+		case "Bucket size":
+			result.BucketSize, err = rd.ReadInt()
+		case "Expansion rate":
+			result.ExpansionRate, err = rd.ReadInt()
+		case "Max iterations":
+			result.MaxIteration, err = rd.ReadInt()
+
+		default:
+			return fmt.Errorf("redis: CF.INFO unexpected key %s", key)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd.val = result
+	return nil
+}
+
+// CFInfo returns information about a Cuckoo filter.
+// For more information - https://redis.io/commands/cf.info/
+func (c cmdable) CFInfo(ctx context.Context, key string) *CFInfoCmd {
+	args := []interface{}{"CF.INFO", key}
+	cmd := NewCFInfoCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFInsert inserts elements into a Cuckoo filter.
+// This function also allows for specifying additional options such as capacity, error rate, expansion rate, and non-scaling behavior.
+// Returns an array of booleans indicating whether each element was added to the filter or not.
+// For more information - https://redis.io/commands/cf.insert/
+func (c cmdable) CFInsert(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *BoolSliceCmd {
+	args := []interface{}{"CF.INSERT", key}
+	args = c.getCfInsertWithArgs(args, options, elements...)
+
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CFInsertNX inserts elements into a Cuckoo filter only if they do not already exist in the filter.
+// This function also allows for specifying additional options such as:
+// capacity, error rate, expansion rate, and non-scaling behavior.
+// Returns an array of integers indicating whether each element was added to the filter or not.
+// For more information - https://redis.io/commands/cf.insertnx/
+func (c cmdable) CFInsertNX(ctx context.Context, key string, options *CFInsertOptions, elements ...interface{}) *IntSliceCmd {
+	args := []interface{}{"CF.INSERTNX", key}
+	args = c.getCfInsertWithArgs(args, options, elements...)
+
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) getCfInsertWithArgs(args []interface{}, options *CFInsertOptions, elements ...interface{}) []interface{} {
+	if options != nil {
+		if options.Capacity != 0 {
+			args = append(args, "CAPACITY", options.Capacity)
+		}
+		if options.NoCreate {
+			args = append(args, "NOCREATE")
+		}
+	}
+	args = append(args, "ITEMS")
+	args = append(args, elements...)
+
+	return args
+}
+
+// CFMExists check if multiple elements exist in a Cuckoo filter.
+// Returns an array of booleans indicating whether each element exists in the filter or not.
+// For more information - https://redis.io/commands/cf.mexists/
+func (c cmdable) CFMExists(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
+	args := []interface{}{"CF.MEXISTS", key}
+	args = append(args, elements...)
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// -------------------------------------------
+// CMS commands
+//-------------------------------------------
+
+// CMSIncrBy increments the count of one or more items in a Count-Min Sketch filter.
+// Returns an array of integers representing the updated count of each item.
+// For more information - https://redis.io/commands/cms.incrby/
+func (c cmdable) CMSIncrBy(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "CMS.INCRBY"
+	args[1] = key
+	args = appendArgs(args, elements)
+
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type CMSInfo struct {
+	Width int64
+	Depth int64
+	Count int64
+}
+
+type CMSInfoCmd struct {
+	baseCmd
+
+	val CMSInfo
+}
+
+func NewCMSInfoCmd(ctx context.Context, args ...interface{}) *CMSInfoCmd {
+	return &CMSInfoCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *CMSInfoCmd) SetVal(val CMSInfo) {
+	cmd.val = val
+}
+
+func (cmd *CMSInfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *CMSInfoCmd) Val() CMSInfo {
+	return cmd.val
+}
+
+func (cmd *CMSInfoCmd) Result() (CMSInfo, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *CMSInfoCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+
+	var key string
+	var result CMSInfo
+	for f := 0; f < n; f++ {
+		key, err = rd.ReadString()
+		if err != nil {
+			return err
+		}
+
+		switch key {
+		case "width":
+			result.Width, err = rd.ReadInt()
+		case "depth":
+			result.Depth, err = rd.ReadInt()
+		case "count":
+			result.Count, err = rd.ReadInt()
+		default:
+			return fmt.Errorf("redis: CMS.INFO unexpected key %s", key)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd.val = result
+	return nil
+}
+
+// CMSInfo returns information about a Count-Min Sketch filter.
+// For more information - https://redis.io/commands/cms.info/
+func (c cmdable) CMSInfo(ctx context.Context, key string) *CMSInfoCmd {
+	args := []interface{}{"CMS.INFO", key}
+	cmd := NewCMSInfoCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CMSInitByDim creates an empty Count-Min Sketch filter with the specified dimensions.
+// For more information - https://redis.io/commands/cms.initbydim/
+func (c cmdable) CMSInitByDim(ctx context.Context, key string, width, depth int64) *StatusCmd {
+	args := []interface{}{"CMS.INITBYDIM", key, width, depth}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CMSInitByProb creates an empty Count-Min Sketch filter with the specified error rate and probability.
+// For more information - https://redis.io/commands/cms.initbyprob/
+func (c cmdable) CMSInitByProb(ctx context.Context, key string, errorRate, probability float64) *StatusCmd {
+	args := []interface{}{"CMS.INITBYPROB", key, errorRate, probability}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CMSMerge merges multiple Count-Min Sketch filters into a single filter.
+// The destination filter must not exist and will be created with the dimensions of the first source filter.
+// The number of items in each source filter must be equal.
+// Returns OK on success or an error if the filters could not be merged.
+// For more information - https://redis.io/commands/cms.merge/
+func (c cmdable) CMSMerge(ctx context.Context, destKey string, sourceKeys ...string) *StatusCmd {
+	args := []interface{}{"CMS.MERGE", destKey, len(sourceKeys)}
+	for _, s := range sourceKeys {
+		args = append(args, s)
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CMSMergeWithWeight merges multiple Count-Min Sketch filters into a single filter with weights for each source filter.
+// The destination filter must not exist and will be created with the dimensions of the first source filter.
+// The number of items in each source filter must be equal.
+// Returns OK on success or an error if the filters could not be merged.
+// For more information - https://redis.io/commands/cms.merge/
+func (c cmdable) CMSMergeWithWeight(ctx context.Context, destKey string, sourceKeys map[string]int64) *StatusCmd {
+	args := make([]interface{}, 0, 4+(len(sourceKeys)*2+1))
+	args = append(args, "CMS.MERGE", destKey, len(sourceKeys))
+
+	if len(sourceKeys) > 0 {
+		sk := make([]interface{}, len(sourceKeys))
+		sw := make([]interface{}, len(sourceKeys))
+
+		i := 0
+		for k, w := range sourceKeys {
+			sk[i] = k
+			sw[i] = w
+			i++
+		}
+
+		args = append(args, sk...)
+		args = append(args, "WEIGHTS")
+		args = append(args, sw...)
+	}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// CMSQuery returns count for item(s).
+// For more information - https://redis.io/commands/cms.query/
+func (c cmdable) CMSQuery(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd {
+	args := []interface{}{"CMS.QUERY", key}
+	args = append(args, elements...)
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// -------------------------------------------
+// TopK commands
+//--------------------------------------------
+
+// TopKAdd adds one or more elements to a Top-K filter.
+// Returns an array of strings representing the items that were removed from the filter, if any.
+// For more information - https://redis.io/commands/topk.add/
+func (c cmdable) TopKAdd(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TOPK.ADD"
+	args[1] = key
+	args = appendArgs(args, elements)
+
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKReserve creates an empty Top-K filter with the specified number of top items to keep.
+// For more information - https://redis.io/commands/topk.reserve/
+func (c cmdable) TopKReserve(ctx context.Context, key string, k int64) *StatusCmd {
+	args := []interface{}{"TOPK.RESERVE", key, k}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKReserveWithOptions creates an empty Top-K filter with the specified number of top items to keep and additional options.
+// This function allows for specifying additional options such as width, depth and decay.
+// For more information - https://redis.io/commands/topk.reserve/
+func (c cmdable) TopKReserveWithOptions(ctx context.Context, key string, k int64, width, depth int64, decay float64) *StatusCmd {
+	args := []interface{}{"TOPK.RESERVE", key, k, width, depth, decay}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type TopKInfo struct {
+	K     int64
+	Width int64
+	Depth int64
+	Decay float64
+}
+
+type TopKInfoCmd struct {
+	baseCmd
+
+	val TopKInfo
+}
+
+func NewTopKInfoCmd(ctx context.Context, args ...interface{}) *TopKInfoCmd {
+	return &TopKInfoCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *TopKInfoCmd) SetVal(val TopKInfo) {
+	cmd.val = val
+}
+
+func (cmd *TopKInfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *TopKInfoCmd) Val() TopKInfo {
+	return cmd.val
+}
+
+func (cmd *TopKInfoCmd) Result() (TopKInfo, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *TopKInfoCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+
+	var key string
+	var result TopKInfo
+	for f := 0; f < n; f++ {
+		key, err = rd.ReadString()
+		if err != nil {
+			return err
+		}
+
+		switch key {
+		case "k":
+			result.K, err = rd.ReadInt()
+		case "width":
+			result.Width, err = rd.ReadInt()
+		case "depth":
+			result.Depth, err = rd.ReadInt()
+		case "decay":
+			result.Decay, err = rd.ReadFloat()
+		default:
+			return fmt.Errorf("redis: topk.info unexpected key %s", key)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd.val = result
+	return nil
+}
+
+// TopKInfo returns information about a Top-K filter.
+// For more information - https://redis.io/commands/topk.info/
+func (c cmdable) TopKInfo(ctx context.Context, key string) *TopKInfoCmd {
+	args := []interface{}{"TOPK.INFO", key}
+
+	cmd := NewTopKInfoCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKQuery check if multiple elements exist in a Top-K filter.
+// Returns an array of booleans indicating whether each element exists in the filter or not.
+// For more information - https://redis.io/commands/topk.query/
+func (c cmdable) TopKQuery(ctx context.Context, key string, elements ...interface{}) *BoolSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TOPK.QUERY"
+	args[1] = key
+	args = appendArgs(args, elements)
+
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKCount returns an estimate of the number of times an item may be in a Top-K filter.
+// For more information - https://redis.io/commands/topk.count/
+func (c cmdable) TopKCount(ctx context.Context, key string, elements ...interface{}) *IntSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TOPK.COUNT"
+	args[1] = key
+	args = appendArgs(args, elements)
+
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKIncrBy increases the count of one or more items in a Top-K filter.
+// For more information - https://redis.io/commands/topk.incrby/
+func (c cmdable) TopKIncrBy(ctx context.Context, key string, elements ...interface{}) *StringSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TOPK.INCRBY"
+	args[1] = key
+	args = appendArgs(args, elements)
+
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKList returns all items in Top-K list.
+// For more information - https://redis.io/commands/topk.list/
+func (c cmdable) TopKList(ctx context.Context, key string) *StringSliceCmd {
+	args := []interface{}{"TOPK.LIST", key}
+
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TopKListWithCount returns all items in Top-K list with their respective count.
+// For more information - https://redis.io/commands/topk.list/
+func (c cmdable) TopKListWithCount(ctx context.Context, key string) *MapStringIntCmd {
+	args := []interface{}{"TOPK.LIST", key, "WITHCOUNT"}
+
+	cmd := NewMapStringIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// -------------------------------------------
+// t-digest commands
+// --------------------------------------------
+
+// TDigestAdd adds one or more elements to a t-Digest data structure.
+// Returns OK on success or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.add/
+func (c cmdable) TDigestAdd(ctx context.Context, key string, elements ...float64) *StatusCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TDIGEST.ADD"
+	args[1] = key
+
+	// Convert floatSlice to []interface{}
+	interfaceSlice := make([]interface{}, len(elements))
+	for i, v := range elements {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestByRank returns an array of values from a t-Digest data structure based on their rank.
+// The rank of an element is its position in the sorted list of all elements in the t-Digest.
+// Returns an array of floats representing the values at the specified ranks or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.byrank/
+func (c cmdable) TDigestByRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd {
+	args := make([]interface{}, 2, 2+len(rank))
+	args[0] = "TDIGEST.BYRANK"
+	args[1] = key
+
+	// Convert uint slice to []interface{}
+	interfaceSlice := make([]interface{}, len(rank))
+	for i, v := range rank {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewFloatSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestByRevRank returns an array of values from a t-Digest data structure based on their reverse rank.
+// The reverse rank of an element is its position in the sorted list of all elements in the t-Digest when sorted in descending order.
+// Returns an array of floats representing the values at the specified ranks or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.byrevrank/
+func (c cmdable) TDigestByRevRank(ctx context.Context, key string, rank ...uint64) *FloatSliceCmd {
+	args := make([]interface{}, 2, 2+len(rank))
+	args[0] = "TDIGEST.BYREVRANK"
+	args[1] = key
+
+	// Convert uint slice to []interface{}
+	interfaceSlice := make([]interface{}, len(rank))
+	for i, v := range rank {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewFloatSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestCDF returns an array of cumulative distribution function (CDF) values for one or more elements in a t-Digest data structure.
+// The CDF value for an element is the fraction of all elements in the t-Digest that are less than or equal to it.
+// Returns an array of floats representing the CDF values for each element or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.cdf/
+func (c cmdable) TDigestCDF(ctx context.Context, key string, elements ...float64) *FloatSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TDIGEST.CDF"
+	args[1] = key
+
+	// Convert floatSlice to []interface{}
+	interfaceSlice := make([]interface{}, len(elements))
+	for i, v := range elements {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewFloatSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestCreate creates an empty t-Digest data structure with default parameters.
+// Returns OK on success or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.create/
+func (c cmdable) TDigestCreate(ctx context.Context, key string) *StatusCmd {
+	args := []interface{}{"TDIGEST.CREATE", key}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestCreateWithCompression creates an empty t-Digest data structure with a specified compression parameter.
+// The compression parameter controls the accuracy and memory usage of the t-Digest.
+// Returns OK on success or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.create/
+func (c cmdable) TDigestCreateWithCompression(ctx context.Context, key string, compression int64) *StatusCmd {
+	args := []interface{}{"TDIGEST.CREATE", key, "COMPRESSION", compression}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type TDigestInfo struct {
+	Compression       int64
+	Capacity          int64
+	MergedNodes       int64
+	UnmergedNodes     int64
+	MergedWeight      int64
+	UnmergedWeight    int64
+	Observations      int64
+	TotalCompressions int64
+	MemoryUsage       int64
+}
+
+type TDigestInfoCmd struct {
+	baseCmd
+
+	val TDigestInfo
+}
+
+func NewTDigestInfoCmd(ctx context.Context, args ...interface{}) *TDigestInfoCmd {
+	return &TDigestInfoCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *TDigestInfoCmd) SetVal(val TDigestInfo) {
+	cmd.val = val
+}
+
+func (cmd *TDigestInfoCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *TDigestInfoCmd) Val() TDigestInfo {
+	return cmd.val
+}
+
+func (cmd *TDigestInfoCmd) Result() (TDigestInfo, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *TDigestInfoCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+
+	var key string
+	var result TDigestInfo
+	for f := 0; f < n; f++ {
+		key, err = rd.ReadString()
+		if err != nil {
+			return err
+		}
+
+		switch key {
+		case "Compression":
+			result.Compression, err = rd.ReadInt()
+		case "Capacity":
+			result.Capacity, err = rd.ReadInt()
+		case "Merged nodes":
+			result.MergedNodes, err = rd.ReadInt()
+		case "Unmerged nodes":
+			result.UnmergedNodes, err = rd.ReadInt()
+		case "Merged weight":
+			result.MergedWeight, err = rd.ReadInt()
+		case "Unmerged weight":
+			result.UnmergedWeight, err = rd.ReadInt()
+		case "Observations":
+			result.Observations, err = rd.ReadInt()
+		case "Total compressions":
+			result.TotalCompressions, err = rd.ReadInt()
+		case "Memory usage":
+			result.MemoryUsage, err = rd.ReadInt()
+		default:
+			return fmt.Errorf("redis: tdigest.info unexpected key %s", key)
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	cmd.val = result
+	return nil
+}
+
+// TDigestInfo returns information about a t-Digest data structure.
+// For more information - https://redis.io/commands/tdigest.info/
+func (c cmdable) TDigestInfo(ctx context.Context, key string) *TDigestInfoCmd {
+	args := []interface{}{"TDIGEST.INFO", key}
+
+	cmd := NewTDigestInfoCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestMax returns the maximum value from a t-Digest data structure.
+// For more information - https://redis.io/commands/tdigest.max/
+func (c cmdable) TDigestMax(ctx context.Context, key string) *FloatCmd {
+	args := []interface{}{"TDIGEST.MAX", key}
+
+	cmd := NewFloatCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type TDigestMergeOptions struct {
+	Compression int64
+	Override    bool
+}
+
+// TDigestMerge merges multiple t-Digest data structures into a single t-Digest.
+// This function also allows for specifying additional options such as compression and override behavior.
+// Returns OK on success or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.merge/
+func (c cmdable) TDigestMerge(ctx context.Context, destKey string, options *TDigestMergeOptions, sourceKeys ...string) *StatusCmd {
+	args := []interface{}{"TDIGEST.MERGE", destKey, len(sourceKeys)}
+
+	for _, sourceKey := range sourceKeys {
+		args = append(args, sourceKey)
+	}
+
+	if options != nil {
+		if options.Compression != 0 {
+			args = append(args, "COMPRESSION", options.Compression)
+		}
+		if options.Override {
+			args = append(args, "OVERRIDE")
+		}
+	}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestMin returns the minimum value from a t-Digest data structure.
+// For more information - https://redis.io/commands/tdigest.min/
+func (c cmdable) TDigestMin(ctx context.Context, key string) *FloatCmd {
+	args := []interface{}{"TDIGEST.MIN", key}
+
+	cmd := NewFloatCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestQuantile returns an array of quantile values for one or more elements in a t-Digest data structure.
+// The quantile value for an element is the fraction of all elements in the t-Digest that are less than or equal to it.
+// Returns an array of floats representing the quantile values for each element or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.quantile/
+func (c cmdable) TDigestQuantile(ctx context.Context, key string, elements ...float64) *FloatSliceCmd {
+	args := make([]interface{}, 2, 2+len(elements))
+	args[0] = "TDIGEST.QUANTILE"
+	args[1] = key
+
+	// Convert floatSlice to []interface{}
+	interfaceSlice := make([]interface{}, len(elements))
+	for i, v := range elements {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewFloatSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestRank returns an array of rank values for one or more elements in a t-Digest data structure.
+// The rank of an element is its position in the sorted list of all elements in the t-Digest.
+// Returns an array of integers representing the rank values for each element or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.rank/
+func (c cmdable) TDigestRank(ctx context.Context, key string, values ...float64) *IntSliceCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "TDIGEST.RANK"
+	args[1] = key
+
+	// Convert floatSlice to []interface{}
+	interfaceSlice := make([]interface{}, len(values))
+	for i, v := range values {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestReset resets a t-Digest data structure to its initial state.
+// Returns OK on success or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.reset/
+func (c cmdable) TDigestReset(ctx context.Context, key string) *StatusCmd {
+	args := []interface{}{"TDIGEST.RESET", key}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestRevRank returns an array of reverse rank values for one or more elements in a t-Digest data structure.
+// The reverse rank of an element is its position in the sorted list of all elements in the t-Digest when sorted in descending order.
+// Returns an array of integers representing the reverse rank values for each element or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.revrank/
+func (c cmdable) TDigestRevRank(ctx context.Context, key string, values ...float64) *IntSliceCmd {
+	args := make([]interface{}, 2, 2+len(values))
+	args[0] = "TDIGEST.REVRANK"
+	args[1] = key
+
+	// Convert floatSlice to []interface{}
+	interfaceSlice := make([]interface{}, len(values))
+	for i, v := range values {
+		interfaceSlice[i] = v
+	}
+
+	args = append(args, interfaceSlice...)
+
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TDigestTrimmedMean returns the trimmed mean value from a t-Digest data structure.
+// The trimmed mean is calculated by removing a specified fraction of the highest and lowest values from the t-Digest and then calculating the mean of the remaining values.
+// Returns a float representing the trimmed mean value or an error if the operation could not be completed.
+// For more information - https://redis.io/commands/tdigest.trimmed_mean/
+func (c cmdable) TDigestTrimmedMean(ctx context.Context, key string, lowCutQuantile, highCutQuantile float64) *FloatCmd {
+	args := []interface{}{"TDIGEST.TRIMMED_MEAN", key, lowCutQuantile, highCutQuantile}
+
+	cmd := NewFloatCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/probabilistic_test.go b/probabilistic_test.go
new file mode 100644
index 000000000..0610c515e
--- /dev/null
+++ b/probabilistic_test.go
@@ -0,0 +1,733 @@
+package redis_test
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+
+	"github.com/redis/go-redis/v9"
+)
+
+var _ = Describe("Probabilistic commands", Label("probabilistic"), func() {
+	ctx := context.TODO()
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(&redis.Options{Addr: ":6379"})
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	Describe("bloom", Label("bloom"), func() {
+		It("should BFAdd", Label("bloom", "bfadd"), func() {
+			resultAdd, err := client.BFAdd(ctx, "testbf1", 1).Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultAdd).To(BeTrue())
+
+			resultInfo, err := client.BFInfo(ctx, "testbf1").Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultInfo).To(BeAssignableToTypeOf(redis.BFInfo{}))
+			Expect(resultInfo.ItemsInserted).To(BeEquivalentTo(int64(1)))
+		})
+
+		It("should BFCard", Label("bloom", "bfcard"), func() {
+			// This is a probabilistic data structure, and it's not always guaranteed that we will get back
+			// the exact number of inserted items, during hash collisions
+			// But with such a low number of items (only 3),
+			// the probability of a collision is very low, so we can expect to get back the exact number of items
+			_, err := client.BFAdd(ctx, "testbf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			_, err = client.BFAdd(ctx, "testbf1", "item2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			_, err = client.BFAdd(ctx, "testbf1", 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.BFCard(ctx, "testbf1").Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeEquivalentTo(int64(3)))
+		})
+
+		It("should BFExists", Label("bloom", "bfexists"), func() {
+			exists, err := client.BFExists(ctx, "testbf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeFalse())
+
+			_, err = client.BFAdd(ctx, "testbf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+
+			exists, err = client.BFExists(ctx, "testbf1", "item1").Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeTrue())
+		})
+
+		It("should BFInfo and BFReserve", Label("bloom", "bfinfo", "bfreserve"), func() {
+			err := client.BFReserve(ctx, "testbf1", 0.001, 2000).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.BFInfo(ctx, "testbf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeAssignableToTypeOf(redis.BFInfo{}))
+			Expect(result.Capacity).To(BeEquivalentTo(int64(2000)))
+		})
+
+		It("should BFInfoCapacity, BFInfoSize, BFInfoFilters, BFInfoItems, BFInfoExpansion, ", Label("bloom", "bfinfocapacity", "bfinfosize", "bfinfofilters", "bfinfoitems", "bfinfoexpansion"), func() {
+			err := client.BFReserve(ctx, "testbf1", 0.001, 2000).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.BFInfoCapacity(ctx, "testbf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.Capacity).To(BeEquivalentTo(int64(2000)))
+
+			result, err = client.BFInfoItems(ctx, "testbf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.ItemsInserted).To(BeEquivalentTo(int64(0)))
+
+			result, err = client.BFInfoSize(ctx, "testbf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.Size).To(BeEquivalentTo(int64(4056)))
+
+			err = client.BFReserveExpansion(ctx, "testbf2", 0.001, 2000, 3).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err = client.BFInfoFilters(ctx, "testbf2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.Filters).To(BeEquivalentTo(int64(1)))
+
+			result, err = client.BFInfoExpansion(ctx, "testbf2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result.ExpansionRate).To(BeEquivalentTo(int64(3)))
+		})
+
+		It("should BFInsert", Label("bloom", "bfinsert"), func() {
+			options := &redis.BFInsertOptions{
+				Capacity:   2000,
+				Error:      0.001,
+				Expansion:  3,
+				NonScaling: false,
+				NoCreate:   true,
+			}
+
+			resultInsert, err := client.BFInsert(ctx, "testbf1", options, "item1").Result()
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(MatchError("ERR not found"))
+
+			options = &redis.BFInsertOptions{
+				Capacity:   2000,
+				Error:      0.001,
+				Expansion:  3,
+				NonScaling: false,
+				NoCreate:   false,
+			}
+
+			resultInsert, err = client.BFInsert(ctx, "testbf1", options, "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultInsert)).To(BeEquivalentTo(1))
+
+			exists, err := client.BFExists(ctx, "testbf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeTrue())
+
+			result, err := client.BFInfo(ctx, "testbf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeAssignableToTypeOf(redis.BFInfo{}))
+			Expect(result.Capacity).To(BeEquivalentTo(int64(2000)))
+			Expect(result.ExpansionRate).To(BeEquivalentTo(int64(3)))
+		})
+
+		It("should BFMAdd", Label("bloom", "bfmadd"), func() {
+			resultAdd, err := client.BFMAdd(ctx, "testbf1", "item1", "item2", "item3").Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultAdd)).To(Equal(3))
+
+			resultInfo, err := client.BFInfo(ctx, "testbf1").Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultInfo).To(BeAssignableToTypeOf(redis.BFInfo{}))
+			Expect(resultInfo.ItemsInserted).To(BeEquivalentTo(int64(3)))
+			resultAdd2, err := client.BFMAdd(ctx, "testbf1", "item1", "item2", "item4").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultAdd2[0]).To(BeFalse())
+			Expect(resultAdd2[1]).To(BeFalse())
+			Expect(resultAdd2[2]).To(BeTrue())
+		})
+
+		It("should BFMExists", Label("bloom", "bfmexists"), func() {
+			exist, err := client.BFMExists(ctx, "testbf1", "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(exist)).To(Equal(3))
+			Expect(exist[0]).To(BeFalse())
+			Expect(exist[1]).To(BeFalse())
+			Expect(exist[2]).To(BeFalse())
+
+			_, err = client.BFMAdd(ctx, "testbf1", "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+
+			exist, err = client.BFMExists(ctx, "testbf1", "item1", "item2", "item3", "item4").Result()
+
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(exist)).To(Equal(4))
+			Expect(exist[0]).To(BeTrue())
+			Expect(exist[1]).To(BeTrue())
+			Expect(exist[2]).To(BeTrue())
+			Expect(exist[3]).To(BeFalse())
+		})
+
+		It("should BFReserveExpansion", Label("bloom", "bfreserveexpansion"), func() {
+			err := client.BFReserveExpansion(ctx, "testbf1", 0.001, 2000, 3).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.BFInfo(ctx, "testbf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeAssignableToTypeOf(redis.BFInfo{}))
+			Expect(result.Capacity).To(BeEquivalentTo(int64(2000)))
+			Expect(result.ExpansionRate).To(BeEquivalentTo(int64(3)))
+		})
+
+		It("should BFReserveNonScaling", Label("bloom", "bfreservenonscaling"), func() {
+			err := client.BFReserveNonScaling(ctx, "testbfns1", 0.001, 1000).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			_, err = client.BFInfo(ctx, "testbfns1").Result()
+			Expect(err).To(HaveOccurred())
+		})
+
+		It("should BFScanDump and BFLoadChunk", Label("bloom", "bfscandump", "bfloadchunk"), func() {
+			err := client.BFReserve(ctx, "testbfsd1", 0.001, 3000).Err()
+			Expect(err).NotTo(HaveOccurred())
+			for i := 0; i < 1000; i++ {
+				client.BFAdd(ctx, "testbfsd1", i)
+			}
+			infBefore := client.BFInfoSize(ctx, "testbfsd1")
+			fd := []redis.ScanDump{}
+			sd, err := client.BFScanDump(ctx, "testbfsd1", 0).Result()
+			for {
+				if sd.Iter == 0 {
+					break
+				}
+				Expect(err).NotTo(HaveOccurred())
+				fd = append(fd, sd)
+				sd, err = client.BFScanDump(ctx, "testbfsd1", sd.Iter).Result()
+			}
+			client.Del(ctx, "testbfsd1")
+			for _, e := range fd {
+				client.BFLoadChunk(ctx, "testbfsd1", e.Iter, e.Data)
+			}
+			infAfter := client.BFInfoSize(ctx, "testbfsd1")
+			Expect(infBefore).To(BeEquivalentTo(infAfter))
+		})
+
+		It("should BFReserveWithArgs", Label("bloom", "bfreserveargs"), func() {
+			options := &redis.BFReserveOptions{
+				Capacity:   2000,
+				Error:      0.001,
+				Expansion:  3,
+				NonScaling: false,
+			}
+			err := client.BFReserveWithArgs(ctx, "testbf", options).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.BFInfo(ctx, "testbf").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeAssignableToTypeOf(redis.BFInfo{}))
+			Expect(result.Capacity).To(BeEquivalentTo(int64(2000)))
+			Expect(result.ExpansionRate).To(BeEquivalentTo(int64(3)))
+		})
+	})
+
+	Describe("cuckoo", Label("cuckoo"), func() {
+		It("should CFAdd", Label("cuckoo", "cfadd"), func() {
+			add, err := client.CFAdd(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(add).To(BeTrue())
+
+			exists, err := client.CFExists(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeTrue())
+
+			info, err := client.CFInfo(ctx, "testcf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info).To(BeAssignableToTypeOf(redis.CFInfo{}))
+			Expect(info.NumItemsInserted).To(BeEquivalentTo(int64(1)))
+		})
+
+		It("should CFAddNX", Label("cuckoo", "cfaddnx"), func() {
+			add, err := client.CFAddNX(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(add).To(BeTrue())
+
+			exists, err := client.CFExists(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeTrue())
+
+			result, err := client.CFAddNX(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeFalse())
+
+			info, err := client.CFInfo(ctx, "testcf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info).To(BeAssignableToTypeOf(redis.CFInfo{}))
+			Expect(info.NumItemsInserted).To(BeEquivalentTo(int64(1)))
+		})
+
+		It("should CFCount", Label("cuckoo", "cfcount"), func() {
+			err := client.CFAdd(ctx, "testcf1", "item1").Err()
+			cnt, err := client.CFCount(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cnt).To(BeEquivalentTo(int64(1)))
+
+			err = client.CFAdd(ctx, "testcf1", "item1").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			cnt, err = client.CFCount(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cnt).To(BeEquivalentTo(int64(2)))
+		})
+
+		It("should CFDel and CFExists", Label("cuckoo", "cfdel", "cfexists"), func() {
+			err := client.CFAdd(ctx, "testcf1", "item1").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			exists, err := client.CFExists(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeTrue())
+
+			del, err := client.CFDel(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(del).To(BeTrue())
+
+			exists, err = client.CFExists(ctx, "testcf1", "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(exists).To(BeFalse())
+		})
+
+		It("should CFInfo and CFReserve", Label("cuckoo", "cfinfo", "cfreserve"), func() {
+			err := client.CFReserve(ctx, "testcf1", 1000).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CFReserveExpansion(ctx, "testcfe1", 1000, 1).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CFReserveBucketSize(ctx, "testcfbs1", 1000, 4).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CFReserveMaxIterations(ctx, "testcfmi1", 1000, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.CFInfo(ctx, "testcf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeAssignableToTypeOf(redis.CFInfo{}))
+		})
+
+		It("should CFScanDump and CFLoadChunk", Label("bloom", "cfscandump", "cfloadchunk"), func() {
+			err := client.CFReserve(ctx, "testcfsd1", 1000).Err()
+			Expect(err).NotTo(HaveOccurred())
+			for i := 0; i < 1000; i++ {
+				Item := fmt.Sprintf("item%d", i)
+				client.CFAdd(ctx, "testcfsd1", Item)
+			}
+			infBefore := client.CFInfo(ctx, "testcfsd1")
+			fd := []redis.ScanDump{}
+			sd, err := client.CFScanDump(ctx, "testcfsd1", 0).Result()
+			for {
+				if sd.Iter == 0 {
+					break
+				}
+				Expect(err).NotTo(HaveOccurred())
+				fd = append(fd, sd)
+				sd, err = client.CFScanDump(ctx, "testcfsd1", sd.Iter).Result()
+			}
+			client.Del(ctx, "testcfsd1")
+			for _, e := range fd {
+				client.CFLoadChunk(ctx, "testcfsd1", e.Iter, e.Data)
+			}
+			infAfter := client.CFInfo(ctx, "testcfsd1")
+			Expect(infBefore).To(BeEquivalentTo(infAfter))
+		})
+
+		It("should CFInfo and CFReserveWithArgs", Label("cuckoo", "cfinfo", "cfreserveargs"), func() {
+			args := &redis.CFReserveOptions{
+				Capacity:      2048,
+				BucketSize:    3,
+				MaxIterations: 15,
+				Expansion:     2,
+			}
+
+			err := client.CFReserveWithArgs(ctx, "testcf1", args).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.CFInfo(ctx, "testcf1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeAssignableToTypeOf(redis.CFInfo{}))
+			Expect(result.BucketSize).To(BeEquivalentTo(int64(3)))
+			Expect(result.MaxIteration).To(BeEquivalentTo(int64(15)))
+			Expect(result.ExpansionRate).To(BeEquivalentTo(int64(2)))
+		})
+
+		It("should CFInsert", Label("cuckoo", "cfinsert"), func() {
+			args := &redis.CFInsertOptions{
+				Capacity: 3000,
+				NoCreate: true,
+			}
+
+			result, err := client.CFInsert(ctx, "testcf1", args, "item1", "item2", "item3").Result()
+			Expect(err).To(HaveOccurred())
+
+			args = &redis.CFInsertOptions{
+				Capacity: 3000,
+				NoCreate: false,
+			}
+
+			result, err = client.CFInsert(ctx, "testcf1", args, "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(result)).To(BeEquivalentTo(3))
+		})
+
+		It("should CFInsertNX", Label("cuckoo", "cfinsertnx"), func() {
+			args := &redis.CFInsertOptions{
+				Capacity: 3000,
+				NoCreate: true,
+			}
+
+			result, err := client.CFInsertNX(ctx, "testcf1", args, "item1", "item2", "item2").Result()
+			Expect(err).To(HaveOccurred())
+
+			args = &redis.CFInsertOptions{
+				Capacity: 3000,
+				NoCreate: false,
+			}
+
+			result, err = client.CFInsertNX(ctx, "testcf2", args, "item1", "item2", "item2").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(result)).To(BeEquivalentTo(3))
+			Expect(result[0]).To(BeEquivalentTo(int64(1)))
+			Expect(result[1]).To(BeEquivalentTo(int64(1)))
+			Expect(result[2]).To(BeEquivalentTo(int64(0)))
+		})
+
+		It("should CFMexists", Label("cuckoo", "cfmexists"), func() {
+			err := client.CFInsert(ctx, "testcf1", nil, "item1", "item2", "item3").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.CFMExists(ctx, "testcf1", "item1", "item2", "item3", "item4").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(result)).To(BeEquivalentTo(4))
+			Expect(result[0]).To(BeTrue())
+			Expect(result[1]).To(BeTrue())
+			Expect(result[2]).To(BeTrue())
+			Expect(result[3]).To(BeFalse())
+		})
+	})
+
+	Describe("CMS", Label("cms"), func() {
+		It("should CMSIncrBy", Label("cms", "cmsincrby"), func() {
+			err := client.CMSInitByDim(ctx, "testcms1", 5, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.CMSIncrBy(ctx, "testcms1", "item1", 1, "item2", 2, "item3", 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(result)).To(BeEquivalentTo(3))
+			Expect(result[0]).To(BeEquivalentTo(int64(1)))
+			Expect(result[1]).To(BeEquivalentTo(int64(2)))
+			Expect(result[2]).To(BeEquivalentTo(int64(3)))
+		})
+
+		It("should CMSInitByDim and CMSInfo", Label("cms", "cmsinitbydim", "cmsinfo"), func() {
+			err := client.CMSInitByDim(ctx, "testcms1", 5, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			info, err := client.CMSInfo(ctx, "testcms1").Result()
+			Expect(err).NotTo(HaveOccurred())
+
+			Expect(info).To(BeAssignableToTypeOf(redis.CMSInfo{}))
+			Expect(info.Width).To(BeEquivalentTo(int64(5)))
+			Expect(info.Depth).To(BeEquivalentTo(int64(10)))
+		})
+
+		It("should CMSInitByProb", Label("cms", "cmsinitbyprob"), func() {
+			err := client.CMSInitByProb(ctx, "testcms1", 0.002, 0.01).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			info, err := client.CMSInfo(ctx, "testcms1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info).To(BeAssignableToTypeOf(redis.CMSInfo{}))
+		})
+
+		It("should CMSMerge, CMSMergeWithWeight and CMSQuery", Label("cms", "cmsmerge", "cmsquery", "NonRedisEnterprise"), func() {
+			err := client.CMSMerge(ctx, "destCms1", "testcms2", "testcms3").Err()
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(MatchError("CMS: key does not exist"))
+
+			err = client.CMSInitByDim(ctx, "destCms1", 5, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CMSInitByDim(ctx, "destCms2", 5, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CMSInitByDim(ctx, "cms1", 2, 20).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CMSInitByDim(ctx, "cms2", 3, 20).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			err = client.CMSMerge(ctx, "destCms1", "cms1", "cms2").Err()
+			Expect(err).To(MatchError("CMS: width/depth is not equal"))
+
+			client.Del(ctx, "cms1", "cms2")
+
+			err = client.CMSInitByDim(ctx, "cms1", 5, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.CMSInitByDim(ctx, "cms2", 5, 10).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			client.CMSIncrBy(ctx, "cms1", "item1", 1, "item2", 2)
+			client.CMSIncrBy(ctx, "cms2", "item2", 2, "item3", 3)
+
+			err = client.CMSMerge(ctx, "destCms1", "cms1", "cms2").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err := client.CMSQuery(ctx, "destCms1", "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(result)).To(BeEquivalentTo(3))
+			Expect(result[0]).To(BeEquivalentTo(int64(1)))
+			Expect(result[1]).To(BeEquivalentTo(int64(4)))
+			Expect(result[2]).To(BeEquivalentTo(int64(3)))
+
+			sourceSketches := map[string]int64{
+				"cms1": 1,
+				"cms2": 2,
+			}
+			err = client.CMSMergeWithWeight(ctx, "destCms2", sourceSketches).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			result, err = client.CMSQuery(ctx, "destCms2", "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(result)).To(BeEquivalentTo(3))
+			Expect(result[0]).To(BeEquivalentTo(int64(1)))
+			Expect(result[1]).To(BeEquivalentTo(int64(6)))
+			Expect(result[2]).To(BeEquivalentTo(int64(6)))
+		})
+	})
+
+	Describe("TopK", Label("topk"), func() {
+		It("should TopKReserve, TopKInfo, TopKAdd, TopKQuery, TopKCount, TopKIncrBy, TopKList, TopKListWithCount", Label("topk", "topkreserve", "topkinfo", "topkadd", "topkquery", "topkcount", "topkincrby", "topklist", "topklistwithcount"), func() {
+			err := client.TopKReserve(ctx, "topk1", 3).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			resultInfo, err := client.TopKInfo(ctx, "topk1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultInfo.K).To(BeEquivalentTo(int64(3)))
+
+			resultAdd, err := client.TopKAdd(ctx, "topk1", "item1", "item2", 3, "item1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultAdd)).To(BeEquivalentTo(int64(4)))
+
+			resultQuery, err := client.TopKQuery(ctx, "topk1", "item1", "item2", 4, 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultQuery)).To(BeEquivalentTo(4))
+			Expect(resultQuery[0]).To(BeTrue())
+			Expect(resultQuery[1]).To(BeTrue())
+			Expect(resultQuery[2]).To(BeFalse())
+			Expect(resultQuery[3]).To(BeTrue())
+
+			resultCount, err := client.TopKCount(ctx, "topk1", "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultCount)).To(BeEquivalentTo(3))
+			Expect(resultCount[0]).To(BeEquivalentTo(int64(2)))
+			Expect(resultCount[1]).To(BeEquivalentTo(int64(1)))
+			Expect(resultCount[2]).To(BeEquivalentTo(int64(0)))
+
+			resultIncr, err := client.TopKIncrBy(ctx, "topk1", "item1", 5, "item2", 10).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultIncr)).To(BeEquivalentTo(2))
+
+			resultCount, err = client.TopKCount(ctx, "topk1", "item1", "item2", "item3").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultCount)).To(BeEquivalentTo(3))
+			Expect(resultCount[0]).To(BeEquivalentTo(int64(7)))
+			Expect(resultCount[1]).To(BeEquivalentTo(int64(11)))
+			Expect(resultCount[2]).To(BeEquivalentTo(int64(0)))
+
+			resultList, err := client.TopKList(ctx, "topk1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultList)).To(BeEquivalentTo(3))
+			Expect(resultList).To(ContainElements("item2", "item1", "3"))
+
+			resultListWithCount, err := client.TopKListWithCount(ctx, "topk1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(resultListWithCount)).To(BeEquivalentTo(3))
+			Expect(resultListWithCount["3"]).To(BeEquivalentTo(int64(1)))
+			Expect(resultListWithCount["item1"]).To(BeEquivalentTo(int64(7)))
+			Expect(resultListWithCount["item2"]).To(BeEquivalentTo(int64(11)))
+		})
+
+		It("should TopKReserveWithOptions", Label("topk", "topkreservewithoptions"), func() {
+			err := client.TopKReserveWithOptions(ctx, "topk1", 3, 1500, 8, 0.5).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			resultInfo, err := client.TopKInfo(ctx, "topk1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultInfo.K).To(BeEquivalentTo(int64(3)))
+			Expect(resultInfo.Width).To(BeEquivalentTo(int64(1500)))
+			Expect(resultInfo.Depth).To(BeEquivalentTo(int64(8)))
+			Expect(resultInfo.Decay).To(BeEquivalentTo(0.5))
+		})
+	})
+
+	Describe("t-digest", Label("tdigest"), func() {
+		It("should TDigestAdd, TDigestCreate, TDigestInfo, TDigestByRank, TDigestByRevRank, TDigestCDF, TDigestMax, TDigestMin, TDigestQuantile, TDigestRank, TDigestRevRank, TDigestTrimmedMean, TDigestReset, ", Label("tdigest", "tdigestadd", "tdigestcreate", "tdigestinfo", "tdigestbyrank", "tdigestbyrevrank", "tdigestcdf", "tdigestmax", "tdigestmin", "tdigestquantile", "tdigestrank", "tdigestrevrank", "tdigesttrimmedmean", "tdigestreset"), func() {
+			err := client.TDigestCreate(ctx, "tdigest1").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			info, err := client.TDigestInfo(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info.Observations).To(BeEquivalentTo(int64(0)))
+
+			// Test with empty sketch
+			byRank, err := client.TDigestByRank(ctx, "tdigest1", 0, 1, 2, 3).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(byRank)).To(BeEquivalentTo(4))
+
+			byRevRank, err := client.TDigestByRevRank(ctx, "tdigest1", 0, 1, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(byRevRank)).To(BeEquivalentTo(3))
+
+			cdf, err := client.TDigestCDF(ctx, "tdigest1", 15, 35, 70).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(cdf)).To(BeEquivalentTo(3))
+
+			max, err := client.TDigestMax(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(math.IsNaN(max)).To(BeTrue())
+
+			min, err := client.TDigestMin(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(math.IsNaN(min)).To(BeTrue())
+
+			quantile, err := client.TDigestQuantile(ctx, "tdigest1", 0.1, 0.2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(quantile)).To(BeEquivalentTo(2))
+
+			rank, err := client.TDigestRank(ctx, "tdigest1", 10, 20).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(rank)).To(BeEquivalentTo(2))
+
+			revRank, err := client.TDigestRevRank(ctx, "tdigest1", 10, 20).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(revRank)).To(BeEquivalentTo(2))
+
+			trimmedMean, err := client.TDigestTrimmedMean(ctx, "tdigest1", 0.1, 0.6).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(math.IsNaN(trimmedMean)).To(BeTrue())
+
+			// Add elements
+			err = client.TDigestAdd(ctx, "tdigest1", 10, 20, 30, 40, 50, 60, 70, 80, 90, 100).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			info, err = client.TDigestInfo(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info.Observations).To(BeEquivalentTo(int64(10)))
+
+			byRank, err = client.TDigestByRank(ctx, "tdigest1", 0, 1, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(byRank)).To(BeEquivalentTo(3))
+			Expect(byRank[0]).To(BeEquivalentTo(float64(10)))
+			Expect(byRank[1]).To(BeEquivalentTo(float64(20)))
+			Expect(byRank[2]).To(BeEquivalentTo(float64(30)))
+
+			byRevRank, err = client.TDigestByRevRank(ctx, "tdigest1", 0, 1, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(byRevRank)).To(BeEquivalentTo(3))
+			Expect(byRevRank[0]).To(BeEquivalentTo(float64(100)))
+			Expect(byRevRank[1]).To(BeEquivalentTo(float64(90)))
+			Expect(byRevRank[2]).To(BeEquivalentTo(float64(80)))
+
+			cdf, err = client.TDigestCDF(ctx, "tdigest1", 15, 35, 70).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(cdf)).To(BeEquivalentTo(3))
+			Expect(cdf[0]).To(BeEquivalentTo(0.1))
+			Expect(cdf[1]).To(BeEquivalentTo(0.3))
+			Expect(cdf[2]).To(BeEquivalentTo(0.65))
+
+			max, err = client.TDigestMax(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(max).To(BeEquivalentTo(float64(100)))
+
+			min, err = client.TDigestMin(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(min).To(BeEquivalentTo(float64(10)))
+
+			quantile, err = client.TDigestQuantile(ctx, "tdigest1", 0.1, 0.2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(quantile)).To(BeEquivalentTo(2))
+			Expect(quantile[0]).To(BeEquivalentTo(float64(20)))
+			Expect(quantile[1]).To(BeEquivalentTo(float64(30)))
+
+			rank, err = client.TDigestRank(ctx, "tdigest1", 10, 20).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(rank)).To(BeEquivalentTo(2))
+			Expect(rank[0]).To(BeEquivalentTo(int64(0)))
+			Expect(rank[1]).To(BeEquivalentTo(int64(1)))
+
+			revRank, err = client.TDigestRevRank(ctx, "tdigest1", 10, 20).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(len(revRank)).To(BeEquivalentTo(2))
+			Expect(revRank[0]).To(BeEquivalentTo(int64(9)))
+			Expect(revRank[1]).To(BeEquivalentTo(int64(8)))
+
+			trimmedMean, err = client.TDigestTrimmedMean(ctx, "tdigest1", 0.1, 0.6).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(trimmedMean).To(BeEquivalentTo(float64(40)))
+
+			reset, err := client.TDigestReset(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(reset).To(BeEquivalentTo("OK"))
+		})
+
+		It("should TDigestCreateWithCompression", Label("tdigest", "tcreatewithcompression"), func() {
+			err := client.TDigestCreateWithCompression(ctx, "tdigest1", 2000).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			info, err := client.TDigestInfo(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info.Compression).To(BeEquivalentTo(int64(2000)))
+		})
+
+		It("should TDigestMerge", Label("tdigest", "tmerge", "NonRedisEnterprise"), func() {
+			err := client.TDigestCreate(ctx, "tdigest1").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.TDigestAdd(ctx, "tdigest1", 10, 20, 30, 40, 50, 60, 70, 80, 90, 100).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			err = client.TDigestCreate(ctx, "tdigest2").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.TDigestAdd(ctx, "tdigest2", 15, 25, 35, 45, 55, 65, 75, 85, 95, 105).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			err = client.TDigestCreate(ctx, "tdigest3").Err()
+			Expect(err).NotTo(HaveOccurred())
+			err = client.TDigestAdd(ctx, "tdigest3", 50, 60, 70, 80, 90, 100, 110, 120, 130, 140).Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			options := &redis.TDigestMergeOptions{
+				Compression: 1000,
+				Override:    false,
+			}
+			err = client.TDigestMerge(ctx, "tdigest1", options, "tdigest2", "tdigest3").Err()
+			Expect(err).NotTo(HaveOccurred())
+
+			info, err := client.TDigestInfo(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(info.Observations).To(BeEquivalentTo(int64(30)))
+			Expect(info.Compression).To(BeEquivalentTo(int64(1000)))
+
+			max, err := client.TDigestMax(ctx, "tdigest1").Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(max).To(BeEquivalentTo(float64(140)))
+		})
+	})
+})
diff --git a/pubsub.go b/pubsub.go
index 16c0f5672..aea96241f 100644
--- a/pubsub.go
+++ b/pubsub.go
@@ -487,11 +487,11 @@ func (c *PubSub) getContext() context.Context {
 
 // Channel returns a Go channel for concurrently receiving messages.
 // The channel is closed together with the PubSub. If the Go channel
-// is blocked full for 30 seconds the message is dropped.
+// is blocked full for 1 minute the message is dropped.
 // Receive* APIs can not be used after channel is created.
 //
 // go-redis periodically sends ping messages to test connection health
-// and re-subscribes if ping can not not received for 30 seconds.
+// and re-subscribes if ping can not received for 1 minute.
 func (c *PubSub) Channel(opts ...ChannelOption) <-chan *Message {
 	c.chOnce.Do(func() {
 		c.msgCh = newChannel(c, opts...)
diff --git a/pubsub_commands.go b/pubsub_commands.go
new file mode 100644
index 000000000..28622aa6b
--- /dev/null
+++ b/pubsub_commands.go
@@ -0,0 +1,76 @@
+package redis
+
+import "context"
+
+type PubSubCmdable interface {
+	Publish(ctx context.Context, channel string, message interface{}) *IntCmd
+	SPublish(ctx context.Context, channel string, message interface{}) *IntCmd
+	PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd
+	PubSubNumSub(ctx context.Context, channels ...string) *MapStringIntCmd
+	PubSubNumPat(ctx context.Context) *IntCmd
+	PubSubShardChannels(ctx context.Context, pattern string) *StringSliceCmd
+	PubSubShardNumSub(ctx context.Context, channels ...string) *MapStringIntCmd
+}
+
+// Publish posts the message to the channel.
+func (c cmdable) Publish(ctx context.Context, channel string, message interface{}) *IntCmd {
+	cmd := NewIntCmd(ctx, "publish", channel, message)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SPublish(ctx context.Context, channel string, message interface{}) *IntCmd {
+	cmd := NewIntCmd(ctx, "spublish", channel, message)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PubSubChannels(ctx context.Context, pattern string) *StringSliceCmd {
+	args := []interface{}{"pubsub", "channels"}
+	if pattern != "*" {
+		args = append(args, pattern)
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PubSubNumSub(ctx context.Context, channels ...string) *MapStringIntCmd {
+	args := make([]interface{}, 2+len(channels))
+	args[0] = "pubsub"
+	args[1] = "numsub"
+	for i, channel := range channels {
+		args[2+i] = channel
+	}
+	cmd := NewMapStringIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PubSubShardChannels(ctx context.Context, pattern string) *StringSliceCmd {
+	args := []interface{}{"pubsub", "shardchannels"}
+	if pattern != "*" {
+		args = append(args, pattern)
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PubSubShardNumSub(ctx context.Context, channels ...string) *MapStringIntCmd {
+	args := make([]interface{}, 2+len(channels))
+	args[0] = "pubsub"
+	args[1] = "shardnumsub"
+	for i, channel := range channels {
+		args[2+i] = channel
+	}
+	cmd := NewMapStringIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) PubSubNumPat(ctx context.Context) *IntCmd {
+	cmd := NewIntCmd(ctx, "pubsub", "numpat")
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/race_test.go b/race_test.go
index d30c79335..aeb2d1fa3 100644
--- a/race_test.go
+++ b/race_test.go
@@ -137,7 +137,7 @@ var _ = Describe("races", func() {
 		})
 	})
 
-	It("should select db", func() {
+	It("should select db", Label("NonRedisEnterprise"), func() {
 		err := client.Set(ctx, "db", 1, 0).Err()
 		Expect(err).NotTo(HaveOccurred())
 
@@ -243,7 +243,7 @@ var _ = Describe("races", func() {
 	})
 })
 
-var _ = Describe("cluster races", func() {
+var _ = Describe("cluster races", Label("NonRedisEnterprise"), func() {
 	var client *redis.ClusterClient
 	var C, N int
 
diff --git a/redis.go b/redis.go
index c7fbd0de8..527afb677 100644
--- a/redis.go
+++ b/redis.go
@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"net"
+	"sync"
 	"sync/atomic"
 	"time"
 
@@ -40,12 +41,15 @@ type (
 )
 
 type hooksMixin struct {
+	hooksMu *sync.Mutex
+
 	slice   []Hook
 	initial hooks
 	current hooks
 }
 
 func (hs *hooksMixin) initHooks(hooks hooks) {
+	hs.hooksMu = new(sync.Mutex)
 	hs.initial = hooks
 	hs.chain()
 }
@@ -116,6 +120,9 @@ func (hs *hooksMixin) AddHook(hook Hook) {
 func (hs *hooksMixin) chain() {
 	hs.initial.setDefaults()
 
+	hs.hooksMu.Lock()
+	defer hs.hooksMu.Unlock()
+
 	hs.current.dial = hs.initial.dial
 	hs.current.process = hs.initial.process
 	hs.current.pipeline = hs.initial.pipeline
@@ -138,9 +145,13 @@ func (hs *hooksMixin) chain() {
 }
 
 func (hs *hooksMixin) clone() hooksMixin {
+	hs.hooksMu.Lock()
+	defer hs.hooksMu.Unlock()
+
 	clone := *hs
 	l := len(clone.slice)
 	clone.slice = clone.slice[:l:l]
+	clone.hooksMu = new(sync.Mutex)
 	return clone
 }
 
@@ -165,6 +176,8 @@ func (hs *hooksMixin) withProcessPipelineHook(
 }
 
 func (hs *hooksMixin) dialHook(ctx context.Context, network, addr string) (net.Conn, error) {
+	hs.hooksMu.Lock()
+	defer hs.hooksMu.Unlock()
 	return hs.current.dial(ctx, network, addr)
 }
 
@@ -270,8 +283,13 @@ func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
 	}
 	cn.Inited = true
 
+	var err error
 	username, password := c.opt.Username, c.opt.Password
-	if c.opt.CredentialsProvider != nil {
+	if c.opt.CredentialsProviderContext != nil {
+		if username, password, err = c.opt.CredentialsProviderContext(ctx); err != nil {
+			return err
+		}
+	} else if c.opt.CredentialsProvider != nil {
 		username, password = c.opt.CredentialsProvider()
 	}
 
@@ -287,7 +305,7 @@ func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
 
 	// for redis-server versions that do not support the HELLO command,
 	// RESP2 will continue to be used.
-	if err := conn.Hello(ctx, protocol, username, password, "").Err(); err == nil {
+	if err = conn.Hello(ctx, protocol, username, password, "").Err(); err == nil {
 		auth = true
 	} else if !isRedisError(err) {
 		// When the server responds with the RESP protocol and the result is not a normal
@@ -300,7 +318,7 @@ func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
 		return err
 	}
 
-	_, err := conn.Pipelined(ctx, func(pipe Pipeliner) error {
+	_, err = conn.Pipelined(ctx, func(pipe Pipeliner) error {
 		if !auth && password != "" {
 			if username != "" {
 				pipe.AuthACL(ctx, username, password)
@@ -327,6 +345,18 @@ func (c *baseClient) initConn(ctx context.Context, cn *pool.Conn) error {
 		return err
 	}
 
+	if !c.opt.DisableIndentity {
+		libName := ""
+		libVer := Version()
+		if c.opt.IdentitySuffix != "" {
+			libName = c.opt.IdentitySuffix
+		}
+		p := conn.Pipeline()
+		p.ClientSetInfo(ctx, WithLibraryName(libName))
+		p.ClientSetInfo(ctx, WithLibraryVersion(libVer))
+		_, _ = p.Exec(ctx)
+	}
+
 	if c.opt.OnConnect != nil {
 		return c.opt.OnConnect(ctx, conn)
 	}
diff --git a/redis_test.go b/redis_test.go
index c9d8df6bf..ef2125452 100644
--- a/redis_test.go
+++ b/redis_test.go
@@ -65,7 +65,11 @@ var _ = Describe("Client", func() {
 	})
 
 	It("should Stringer", func() {
-		Expect(client.String()).To(Equal(fmt.Sprintf("Redis<:%s db:15>", redisPort)))
+		if RECluster {
+			Expect(client.String()).To(Equal(fmt.Sprintf("Redis<:%s db:0>", redisPort)))
+		} else {
+			Expect(client.String()).To(Equal(fmt.Sprintf("Redis<:%s db:15>", redisPort)))
+		}
 	})
 
 	It("supports context", func() {
@@ -76,7 +80,7 @@ var _ = Describe("Client", func() {
 		Expect(err).To(MatchError("context canceled"))
 	})
 
-	It("supports WithTimeout", func() {
+	It("supports WithTimeout", Label("NonRedisEnterprise"), func() {
 		err := client.ClientPause(ctx, time.Second).Err()
 		Expect(err).NotTo(HaveOccurred())
 
@@ -151,7 +155,7 @@ var _ = Describe("Client", func() {
 		Expect(pubsub.Close()).NotTo(HaveOccurred())
 	})
 
-	It("should select DB", func() {
+	It("should select DB", Label("NonRedisEnterprise"), func() {
 		db2 := redis.NewClient(&redis.Options{
 			Addr: redisAddr,
 			DB:   2,
@@ -465,7 +469,7 @@ var _ = Describe("Client OnConnect", func() {
 	})
 })
 
-var _ = Describe("Client context cancelation", func() {
+var _ = Describe("Client context cancellation", func() {
 	var opt *redis.Options
 	var client *redis.Client
 
@@ -480,7 +484,7 @@ var _ = Describe("Client context cancelation", func() {
 		Expect(client.Close()).NotTo(HaveOccurred())
 	})
 
-	It("Blocking operation cancelation", func() {
+	It("Blocking operation cancellation", func() {
 		ctx, cancel := context.WithCancel(ctx)
 		cancel()
 
@@ -503,7 +507,7 @@ var _ = Describe("Conn", func() {
 		Expect(err).NotTo(HaveOccurred())
 	})
 
-	It("TxPipeline", func() {
+	It("TxPipeline", Label("NonRedisEnterprise"), func() {
 		tx := client.Conn().TxPipeline()
 		tx.SwapDB(ctx, 0, 2)
 		tx.SwapDB(ctx, 1, 0)
@@ -558,4 +562,74 @@ var _ = Describe("Hook", func() {
 			"hook-1-process-end",
 		}))
 	})
+
+	It("wrapped error in a hook", func() {
+		client.AddHook(&hook{
+			processHook: func(hook redis.ProcessHook) redis.ProcessHook {
+				return func(ctx context.Context, cmd redis.Cmder) error {
+					if err := hook(ctx, cmd); err != nil {
+						return fmt.Errorf("wrapped error: %w", err)
+					}
+					return nil
+				}
+			},
+		})
+		client.ScriptFlush(ctx)
+
+		script := redis.NewScript(`return 'Script and hook'`)
+
+		cmd := script.Run(ctx, client, nil)
+		Expect(cmd.Err()).NotTo(HaveOccurred())
+		Expect(cmd.Val()).To(Equal("Script and hook"))
+	})
+})
+
+var _ = Describe("Hook with MinIdleConns", func() {
+	var client *redis.Client
+
+	BeforeEach(func() {
+		options := redisOptions()
+		options.MinIdleConns = 1
+		client = redis.NewClient(options)
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		err := client.Close()
+		Expect(err).NotTo(HaveOccurred())
+	})
+
+	It("fifo", func() {
+		var res []string
+		client.AddHook(&hook{
+			processHook: func(hook redis.ProcessHook) redis.ProcessHook {
+				return func(ctx context.Context, cmd redis.Cmder) error {
+					res = append(res, "hook-1-process-start")
+					err := hook(ctx, cmd)
+					res = append(res, "hook-1-process-end")
+					return err
+				}
+			},
+		})
+		client.AddHook(&hook{
+			processHook: func(hook redis.ProcessHook) redis.ProcessHook {
+				return func(ctx context.Context, cmd redis.Cmder) error {
+					res = append(res, "hook-2-process-start")
+					err := hook(ctx, cmd)
+					res = append(res, "hook-2-process-end")
+					return err
+				}
+			},
+		})
+
+		err := client.Ping(ctx).Err()
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(res).To(Equal([]string{
+			"hook-1-process-start",
+			"hook-2-process-start",
+			"hook-2-process-end",
+			"hook-1-process-end",
+		}))
+	})
 })
diff --git a/ring.go b/ring.go
index 0572ba346..4ae00542b 100644
--- a/ring.go
+++ b/ring.go
@@ -79,9 +79,10 @@ type RingOptions struct {
 	MinRetryBackoff time.Duration
 	MaxRetryBackoff time.Duration
 
-	DialTimeout  time.Duration
-	ReadTimeout  time.Duration
-	WriteTimeout time.Duration
+	DialTimeout           time.Duration
+	ReadTimeout           time.Duration
+	WriteTimeout          time.Duration
+	ContextTimeoutEnabled bool
 
 	// PoolFIFO uses FIFO mode for each node connection pool GET/PUT (default LIFO).
 	PoolFIFO bool
@@ -90,11 +91,15 @@ type RingOptions struct {
 	PoolTimeout     time.Duration
 	MinIdleConns    int
 	MaxIdleConns    int
+	MaxActiveConns  int
 	ConnMaxIdleTime time.Duration
 	ConnMaxLifetime time.Duration
 
 	TLSConfig *tls.Config
 	Limiter   Limiter
+
+	DisableIndentity bool
+	IdentitySuffix   string
 }
 
 func (opt *RingOptions) init() {
@@ -144,20 +149,25 @@ func (opt *RingOptions) clientOptions() *Options {
 
 		MaxRetries: -1,
 
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
+		DialTimeout:           opt.DialTimeout,
+		ReadTimeout:           opt.ReadTimeout,
+		WriteTimeout:          opt.WriteTimeout,
+		ContextTimeoutEnabled: opt.ContextTimeoutEnabled,
 
 		PoolFIFO:        opt.PoolFIFO,
 		PoolSize:        opt.PoolSize,
 		PoolTimeout:     opt.PoolTimeout,
 		MinIdleConns:    opt.MinIdleConns,
 		MaxIdleConns:    opt.MaxIdleConns,
+		MaxActiveConns:  opt.MaxActiveConns,
 		ConnMaxIdleTime: opt.ConnMaxIdleTime,
 		ConnMaxLifetime: opt.ConnMaxLifetime,
 
 		TLSConfig: opt.TLSConfig,
 		Limiter:   opt.Limiter,
+
+		DisableIndentity: opt.DisableIndentity,
+		IdentitySuffix:   opt.IdentitySuffix,
 	}
 }
 
@@ -292,7 +302,6 @@ func (c *ringSharding) SetAddrs(addrs map[string]string) {
 func (c *ringSharding) newRingShards(
 	addrs map[string]string, existing *ringShards,
 ) (shards *ringShards, created, unused map[string]*ringShard) {
-
 	shards = &ringShards{m: make(map[string]*ringShard, len(addrs))}
 	created = make(map[string]*ringShard) // indexed by addr
 	unused = make(map[string]*ringShard)  // indexed by addr
@@ -671,21 +680,8 @@ func (c *Ring) cmdsInfo(ctx context.Context) (map[string]*CommandInfo, error) {
 	return nil, firstErr
 }
 
-func (c *Ring) cmdInfo(ctx context.Context, name string) *CommandInfo {
-	cmdsInfo, err := c.cmdsInfoCache.Get(ctx)
-	if err != nil {
-		return nil
-	}
-	info := cmdsInfo[name]
-	if info == nil {
-		internal.Logger.Printf(ctx, "info for cmd=%s not found", name)
-	}
-	return info
-}
-
 func (c *Ring) cmdShard(ctx context.Context, cmd Cmder) (*ringShard, error) {
-	cmdInfo := c.cmdInfo(ctx, cmd.Name())
-	pos := cmdFirstKeyPos(cmd, cmdInfo)
+	pos := cmdFirstKeyPos(cmd)
 	if pos == 0 {
 		return c.sharding.Random()
 	}
@@ -753,8 +749,7 @@ func (c *Ring) generalProcessPipeline(
 	cmdsMap := make(map[string][]Cmder)
 
 	for _, cmd := range cmds {
-		cmdInfo := c.cmdInfo(ctx, cmd.Name())
-		hash := cmd.stringArg(cmdFirstKeyPos(cmd, cmdInfo))
+		hash := cmd.stringArg(cmdFirstKeyPos(cmd))
 		if hash != "" {
 			hash = c.sharding.Hash(hash)
 		}
diff --git a/scripting_commands.go b/scripting_commands.go
new file mode 100644
index 000000000..af9c3397b
--- /dev/null
+++ b/scripting_commands.go
@@ -0,0 +1,215 @@
+package redis
+
+import "context"
+
+type ScriptingFunctionsCmdable interface {
+	Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
+	EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
+	EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd
+	EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd
+	ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd
+	ScriptFlush(ctx context.Context) *StatusCmd
+	ScriptKill(ctx context.Context) *StatusCmd
+	ScriptLoad(ctx context.Context, script string) *StringCmd
+
+	FunctionLoad(ctx context.Context, code string) *StringCmd
+	FunctionLoadReplace(ctx context.Context, code string) *StringCmd
+	FunctionDelete(ctx context.Context, libName string) *StringCmd
+	FunctionFlush(ctx context.Context) *StringCmd
+	FunctionKill(ctx context.Context) *StringCmd
+	FunctionFlushAsync(ctx context.Context) *StringCmd
+	FunctionList(ctx context.Context, q FunctionListQuery) *FunctionListCmd
+	FunctionDump(ctx context.Context) *StringCmd
+	FunctionRestore(ctx context.Context, libDump string) *StringCmd
+	FunctionStats(ctx context.Context) *FunctionStatsCmd
+	FCall(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
+	FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
+	FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd
+}
+
+func (c cmdable) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
+	return c.eval(ctx, "eval", script, keys, args...)
+}
+
+func (c cmdable) EvalRO(ctx context.Context, script string, keys []string, args ...interface{}) *Cmd {
+	return c.eval(ctx, "eval_ro", script, keys, args...)
+}
+
+func (c cmdable) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
+	return c.eval(ctx, "evalsha", sha1, keys, args...)
+}
+
+func (c cmdable) EvalShaRO(ctx context.Context, sha1 string, keys []string, args ...interface{}) *Cmd {
+	return c.eval(ctx, "evalsha_ro", sha1, keys, args...)
+}
+
+func (c cmdable) eval(ctx context.Context, name, payload string, keys []string, args ...interface{}) *Cmd {
+	cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
+	cmdArgs[0] = name
+	cmdArgs[1] = payload
+	cmdArgs[2] = len(keys)
+	for i, key := range keys {
+		cmdArgs[3+i] = key
+	}
+	cmdArgs = appendArgs(cmdArgs, args)
+	cmd := NewCmd(ctx, cmdArgs...)
+
+	// it is possible that only args exist without a key.
+	// rdb.eval(ctx, eval, script, nil, arg1, arg2)
+	if len(keys) > 0 {
+		cmd.SetFirstKeyPos(3)
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ScriptExists(ctx context.Context, hashes ...string) *BoolSliceCmd {
+	args := make([]interface{}, 2+len(hashes))
+	args[0] = "script"
+	args[1] = "exists"
+	for i, hash := range hashes {
+		args[2+i] = hash
+	}
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ScriptFlush(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "script", "flush")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ScriptKill(ctx context.Context) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "script", "kill")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ScriptLoad(ctx context.Context, script string) *StringCmd {
+	cmd := NewStringCmd(ctx, "script", "load", script)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ------------------------------------------------------------------------------
+
+// FunctionListQuery is used with FunctionList to query for Redis libraries
+//
+//	  	LibraryNamePattern 	- Use an empty string to get all libraries.
+//	  						- Use a glob-style pattern to match multiple libraries with a matching name
+//	  						- Use a library's full name to match a single library
+//		WithCode			- If true, it will return the code of the library
+type FunctionListQuery struct {
+	LibraryNamePattern string
+	WithCode           bool
+}
+
+func (c cmdable) FunctionLoad(ctx context.Context, code string) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "load", code)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionLoadReplace(ctx context.Context, code string) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "load", "replace", code)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionDelete(ctx context.Context, libName string) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "delete", libName)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionFlush(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "flush")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionKill(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "kill")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionFlushAsync(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "flush", "async")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionList(ctx context.Context, q FunctionListQuery) *FunctionListCmd {
+	args := make([]interface{}, 2, 5)
+	args[0] = "function"
+	args[1] = "list"
+	if q.LibraryNamePattern != "" {
+		args = append(args, "libraryname", q.LibraryNamePattern)
+	}
+	if q.WithCode {
+		args = append(args, "withcode")
+	}
+	cmd := NewFunctionListCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionDump(ctx context.Context) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "dump")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionRestore(ctx context.Context, libDump string) *StringCmd {
+	cmd := NewStringCmd(ctx, "function", "restore", libDump)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FunctionStats(ctx context.Context) *FunctionStatsCmd {
+	cmd := NewFunctionStatsCmd(ctx, "function", "stats")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) FCall(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
+	cmdArgs := fcallArgs("fcall", function, keys, args...)
+	cmd := NewCmd(ctx, cmdArgs...)
+	if len(keys) > 0 {
+		cmd.SetFirstKeyPos(3)
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// FCallRo this function simply calls FCallRO,
+// Deprecated: to maintain convention FCallRO.
+func (c cmdable) FCallRo(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
+	return c.FCallRO(ctx, function, keys, args...)
+}
+
+func (c cmdable) FCallRO(ctx context.Context, function string, keys []string, args ...interface{}) *Cmd {
+	cmdArgs := fcallArgs("fcall_ro", function, keys, args...)
+	cmd := NewCmd(ctx, cmdArgs...)
+	if len(keys) > 0 {
+		cmd.SetFirstKeyPos(3)
+	}
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func fcallArgs(command string, function string, keys []string, args ...interface{}) []interface{} {
+	cmdArgs := make([]interface{}, 3+len(keys), 3+len(keys)+len(args))
+	cmdArgs[0] = command
+	cmdArgs[1] = function
+	cmdArgs[2] = len(keys)
+	for i, key := range keys {
+		cmdArgs[3+i] = key
+	}
+
+	cmdArgs = append(cmdArgs, args...)
+	return cmdArgs
+}
diff --git a/scripts/release.sh b/scripts/release.sh
index cd4ddee53..fb7d58788 100755
--- a/scripts/release.sh
+++ b/scripts/release.sh
@@ -60,9 +60,6 @@ do
 done
 
 sed --in-place "s/\(return \)\"[^\"]*\"/\1\"${TAG#v}\"/" ./version.go
-sed --in-place "s/\(\"version\": \)\"[^\"]*\"/\1\"${TAG#v}\"/" ./package.json
-
-conventional-changelog -p angular -i CHANGELOG.md -s
 
 git checkout -b release/${TAG} master
 git add -u
diff --git a/sentinel.go b/sentinel.go
index dbff40603..188f88494 100644
--- a/sentinel.go
+++ b/sentinel.go
@@ -74,10 +74,14 @@ type FailoverOptions struct {
 	PoolTimeout     time.Duration
 	MinIdleConns    int
 	MaxIdleConns    int
+	MaxActiveConns  int
 	ConnMaxIdleTime time.Duration
 	ConnMaxLifetime time.Duration
 
 	TLSConfig *tls.Config
+
+	DisableIndentity bool
+	IdentitySuffix   string
 }
 
 func (opt *FailoverOptions) clientOptions() *Options {
@@ -107,10 +111,14 @@ func (opt *FailoverOptions) clientOptions() *Options {
 		PoolTimeout:     opt.PoolTimeout,
 		MinIdleConns:    opt.MinIdleConns,
 		MaxIdleConns:    opt.MaxIdleConns,
+		MaxActiveConns:  opt.MaxActiveConns,
 		ConnMaxIdleTime: opt.ConnMaxIdleTime,
 		ConnMaxLifetime: opt.ConnMaxLifetime,
 
 		TLSConfig: opt.TLSConfig,
+
+		DisableIndentity: opt.DisableIndentity,
+		IdentitySuffix:   opt.IdentitySuffix,
 	}
 }
 
@@ -130,19 +138,24 @@ func (opt *FailoverOptions) sentinelOptions(addr string) *Options {
 		MinRetryBackoff: opt.MinRetryBackoff,
 		MaxRetryBackoff: opt.MaxRetryBackoff,
 
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
+		DialTimeout:           opt.DialTimeout,
+		ReadTimeout:           opt.ReadTimeout,
+		WriteTimeout:          opt.WriteTimeout,
+		ContextTimeoutEnabled: opt.ContextTimeoutEnabled,
 
 		PoolFIFO:        opt.PoolFIFO,
 		PoolSize:        opt.PoolSize,
 		PoolTimeout:     opt.PoolTimeout,
 		MinIdleConns:    opt.MinIdleConns,
 		MaxIdleConns:    opt.MaxIdleConns,
+		MaxActiveConns:  opt.MaxActiveConns,
 		ConnMaxIdleTime: opt.ConnMaxIdleTime,
 		ConnMaxLifetime: opt.ConnMaxLifetime,
 
 		TLSConfig: opt.TLSConfig,
+
+		DisableIndentity: opt.DisableIndentity,
+		IdentitySuffix:   opt.IdentitySuffix,
 	}
 }
 
@@ -165,19 +178,24 @@ func (opt *FailoverOptions) clusterOptions() *ClusterOptions {
 		MinRetryBackoff: opt.MinRetryBackoff,
 		MaxRetryBackoff: opt.MaxRetryBackoff,
 
-		DialTimeout:  opt.DialTimeout,
-		ReadTimeout:  opt.ReadTimeout,
-		WriteTimeout: opt.WriteTimeout,
+		DialTimeout:           opt.DialTimeout,
+		ReadTimeout:           opt.ReadTimeout,
+		WriteTimeout:          opt.WriteTimeout,
+		ContextTimeoutEnabled: opt.ContextTimeoutEnabled,
 
 		PoolFIFO:        opt.PoolFIFO,
 		PoolSize:        opt.PoolSize,
 		PoolTimeout:     opt.PoolTimeout,
 		MinIdleConns:    opt.MinIdleConns,
 		MaxIdleConns:    opt.MaxIdleConns,
+		MaxActiveConns:  opt.MaxActiveConns,
 		ConnMaxIdleTime: opt.ConnMaxIdleTime,
 		ConnMaxLifetime: opt.ConnMaxLifetime,
 
 		TLSConfig: opt.TLSConfig,
+
+		DisableIndentity: opt.DisableIndentity,
+		IdentitySuffix:   opt.IdentitySuffix,
 	}
 }
 
diff --git a/sentinel_test.go b/sentinel_test.go
index 705b6a094..8bc6c5785 100644
--- a/sentinel_test.go
+++ b/sentinel_test.go
@@ -241,6 +241,7 @@ var _ = Describe("NewFailoverClusterClient", func() {
 	})
 
 	It("should facilitate failover", func() {
+		Skip("Flaky Test")
 		// Set value.
 		err := client.Set(ctx, "foo", "master", 0).Err()
 		Expect(err).NotTo(HaveOccurred())
@@ -283,6 +284,7 @@ var _ = Describe("NewFailoverClusterClient", func() {
 	})
 
 	It("should sentinel cluster client setname", func() {
+		Skip("Flaky Test")
 		err := client.ForEachShard(ctx, func(ctx context.Context, c *redis.Client) error {
 			return c.Ping(ctx).Err()
 		})
@@ -297,6 +299,7 @@ var _ = Describe("NewFailoverClusterClient", func() {
 	})
 
 	It("should sentinel cluster PROTO 3", func() {
+		Skip("Flaky Test")
 		_ = client.ForEachShard(ctx, func(ctx context.Context, c *redis.Client) error {
 			val, err := client.Do(ctx, "HELLO").Result()
 			Expect(err).NotTo(HaveOccurred())
@@ -321,7 +324,7 @@ var _ = Describe("SentinelAclAuth", func() {
 	BeforeEach(func() {
 		authCmd := redis.NewStatusCmd(ctx, "ACL", "SETUSER", aclSentinelUsername, "ON",
 			">"+aclSentinelPassword, "-@all", "+auth", "+client|getname", "+client|id", "+client|setname",
-			"+command", "+hello", "+ping", "+role", "+sentinel|get-master-addr-by-name", "+sentinel|master",
+			"+command", "+hello", "+ping", "+client|setinfo", "+role", "+sentinel|get-master-addr-by-name", "+sentinel|master",
 			"+sentinel|myid", "+sentinel|replicas", "+sentinel|sentinels")
 
 		for _, process := range sentinels() {
diff --git a/set_commands.go b/set_commands.go
new file mode 100644
index 000000000..cef8ad6d8
--- /dev/null
+++ b/set_commands.go
@@ -0,0 +1,217 @@
+package redis
+
+import "context"
+
+type SetCmdable interface {
+	SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd
+	SCard(ctx context.Context, key string) *IntCmd
+	SDiff(ctx context.Context, keys ...string) *StringSliceCmd
+	SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
+	SInter(ctx context.Context, keys ...string) *StringSliceCmd
+	SInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
+	SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd
+	SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd
+	SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd
+	SMembers(ctx context.Context, key string) *StringSliceCmd
+	SMembersMap(ctx context.Context, key string) *StringStructMapCmd
+	SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd
+	SPop(ctx context.Context, key string) *StringCmd
+	SPopN(ctx context.Context, key string, count int64) *StringSliceCmd
+	SRandMember(ctx context.Context, key string) *StringCmd
+	SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd
+	SRem(ctx context.Context, key string, members ...interface{}) *IntCmd
+	SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
+	SUnion(ctx context.Context, keys ...string) *StringSliceCmd
+	SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd
+}
+
+//------------------------------------------------------------------------------
+
+func (c cmdable) SAdd(ctx context.Context, key string, members ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(members))
+	args[0] = "sadd"
+	args[1] = key
+	args = appendArgs(args, members)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SCard(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "scard", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SDiff(ctx context.Context, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "sdiff"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "sdiffstore"
+	args[1] = destination
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SInter(ctx context.Context, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "sinter"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd {
+	args := make([]interface{}, 4+len(keys))
+	args[0] = "sintercard"
+	numkeys := int64(0)
+	for i, key := range keys {
+		args[2+i] = key
+		numkeys++
+	}
+	args[1] = numkeys
+	args[2+numkeys] = "limit"
+	args[3+numkeys] = limit
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SInterStore(ctx context.Context, destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "sinterstore"
+	args[1] = destination
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SIsMember(ctx context.Context, key string, member interface{}) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "sismember", key, member)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SMIsMember Redis `SMISMEMBER key member [member ...]` command.
+func (c cmdable) SMIsMember(ctx context.Context, key string, members ...interface{}) *BoolSliceCmd {
+	args := make([]interface{}, 2, 2+len(members))
+	args[0] = "smismember"
+	args[1] = key
+	args = appendArgs(args, members)
+	cmd := NewBoolSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SMembers Redis `SMEMBERS key` command output as a slice.
+func (c cmdable) SMembers(ctx context.Context, key string) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "smembers", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SMembersMap Redis `SMEMBERS key` command output as a map.
+func (c cmdable) SMembersMap(ctx context.Context, key string) *StringStructMapCmd {
+	cmd := NewStringStructMapCmd(ctx, "smembers", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SMove(ctx context.Context, source, destination string, member interface{}) *BoolCmd {
+	cmd := NewBoolCmd(ctx, "smove", source, destination, member)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SPop Redis `SPOP key` command.
+func (c cmdable) SPop(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "spop", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SPopN Redis `SPOP key count` command.
+func (c cmdable) SPopN(ctx context.Context, key string, count int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "spop", key, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SRandMember Redis `SRANDMEMBER key` command.
+func (c cmdable) SRandMember(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "srandmember", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SRandMemberN Redis `SRANDMEMBER key count` command.
+func (c cmdable) SRandMemberN(ctx context.Context, key string, count int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "srandmember", key, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(members))
+	args[0] = "srem"
+	args[1] = key
+	args = appendArgs(args, members)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SUnion(ctx context.Context, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "sunion"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SUnionStore(ctx context.Context, destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "sunionstore"
+	args[1] = destination
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"sscan", key, cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(ctx, c, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/sortedset_commands.go b/sortedset_commands.go
new file mode 100644
index 000000000..670140270
--- /dev/null
+++ b/sortedset_commands.go
@@ -0,0 +1,772 @@
+package redis
+
+import (
+	"context"
+	"strings"
+	"time"
+)
+
+type SortedSetCmdable interface {
+	BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
+	BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd
+	BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd
+	ZAdd(ctx context.Context, key string, members ...Z) *IntCmd
+	ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd
+	ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd
+	ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd
+	ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd
+	ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd
+	ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd
+	ZCard(ctx context.Context, key string) *IntCmd
+	ZCount(ctx context.Context, key, min, max string) *IntCmd
+	ZLexCount(ctx context.Context, key, min, max string) *IntCmd
+	ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd
+	ZInter(ctx context.Context, store *ZStore) *StringSliceCmd
+	ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd
+	ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd
+	ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd
+	ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd
+	ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd
+	ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd
+	ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd
+	ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
+	ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
+	ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
+	ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
+	ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
+	ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd
+	ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd
+	ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd
+	ZRank(ctx context.Context, key, member string) *IntCmd
+	ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
+	ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd
+	ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd
+	ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd
+	ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd
+	ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd
+	ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd
+	ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
+	ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd
+	ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd
+	ZRevRank(ctx context.Context, key, member string) *IntCmd
+	ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd
+	ZScore(ctx context.Context, key, member string) *FloatCmd
+	ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd
+	ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd
+	ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd
+	ZUnion(ctx context.Context, store ZStore) *StringSliceCmd
+	ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd
+	ZDiff(ctx context.Context, keys ...string) *StringSliceCmd
+	ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd
+	ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd
+	ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd
+}
+
+// BZPopMax Redis `BZPOPMAX key [key ...] timeout` command.
+func (c cmdable) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
+	args := make([]interface{}, 1+len(keys)+1)
+	args[0] = "bzpopmax"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	args[len(args)-1] = formatSec(ctx, timeout)
+	cmd := NewZWithKeyCmd(ctx, args...)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BZPopMin Redis `BZPOPMIN key [key ...] timeout` command.
+func (c cmdable) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *ZWithKeyCmd {
+	args := make([]interface{}, 1+len(keys)+1)
+	args[0] = "bzpopmin"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	args[len(args)-1] = formatSec(ctx, timeout)
+	cmd := NewZWithKeyCmd(ctx, args...)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// BZMPop is the blocking variant of ZMPOP.
+// When any of the sorted sets contains elements, this command behaves exactly like ZMPOP.
+// When all sorted sets are empty, Redis will block the connection until another client adds members to one of the keys or until the timeout elapses.
+// A timeout of zero can be used to block indefinitely.
+// example: client.BZMPop(ctx, 0,"max", 1, "set")
+func (c cmdable) BZMPop(ctx context.Context, timeout time.Duration, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
+	args := make([]interface{}, 3+len(keys), 6+len(keys))
+	args[0] = "bzmpop"
+	args[1] = formatSec(ctx, timeout)
+	args[2] = len(keys)
+	for i, key := range keys {
+		args[3+i] = key
+	}
+	args = append(args, strings.ToLower(order), "count", count)
+	cmd := NewZSliceWithKeyCmd(ctx, args...)
+	cmd.setReadTimeout(timeout)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZAddArgs WARN: The GT, LT and NX options are mutually exclusive.
+type ZAddArgs struct {
+	NX      bool
+	XX      bool
+	LT      bool
+	GT      bool
+	Ch      bool
+	Members []Z
+}
+
+func (c cmdable) zAddArgs(key string, args ZAddArgs, incr bool) []interface{} {
+	a := make([]interface{}, 0, 6+2*len(args.Members))
+	a = append(a, "zadd", key)
+
+	// The GT, LT and NX options are mutually exclusive.
+	if args.NX {
+		a = append(a, "nx")
+	} else {
+		if args.XX {
+			a = append(a, "xx")
+		}
+		if args.GT {
+			a = append(a, "gt")
+		} else if args.LT {
+			a = append(a, "lt")
+		}
+	}
+	if args.Ch {
+		a = append(a, "ch")
+	}
+	if incr {
+		a = append(a, "incr")
+	}
+	for _, m := range args.Members {
+		a = append(a, m.Score)
+		a = append(a, m.Member)
+	}
+	return a
+}
+
+func (c cmdable) ZAddArgs(ctx context.Context, key string, args ZAddArgs) *IntCmd {
+	cmd := NewIntCmd(ctx, c.zAddArgs(key, args, false)...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZAddArgsIncr(ctx context.Context, key string, args ZAddArgs) *FloatCmd {
+	cmd := NewFloatCmd(ctx, c.zAddArgs(key, args, true)...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZAdd Redis `ZADD key score member [score member ...]` command.
+func (c cmdable) ZAdd(ctx context.Context, key string, members ...Z) *IntCmd {
+	return c.ZAddArgs(ctx, key, ZAddArgs{
+		Members: members,
+	})
+}
+
+// ZAddLT Redis `ZADD key LT score member [score member ...]` command.
+func (c cmdable) ZAddLT(ctx context.Context, key string, members ...Z) *IntCmd {
+	return c.ZAddArgs(ctx, key, ZAddArgs{
+		LT:      true,
+		Members: members,
+	})
+}
+
+// ZAddGT Redis `ZADD key GT score member [score member ...]` command.
+func (c cmdable) ZAddGT(ctx context.Context, key string, members ...Z) *IntCmd {
+	return c.ZAddArgs(ctx, key, ZAddArgs{
+		GT:      true,
+		Members: members,
+	})
+}
+
+// ZAddNX Redis `ZADD key NX score member [score member ...]` command.
+func (c cmdable) ZAddNX(ctx context.Context, key string, members ...Z) *IntCmd {
+	return c.ZAddArgs(ctx, key, ZAddArgs{
+		NX:      true,
+		Members: members,
+	})
+}
+
+// ZAddXX Redis `ZADD key XX score member [score member ...]` command.
+func (c cmdable) ZAddXX(ctx context.Context, key string, members ...Z) *IntCmd {
+	return c.ZAddArgs(ctx, key, ZAddArgs{
+		XX:      true,
+		Members: members,
+	})
+}
+
+func (c cmdable) ZCard(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zcard", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZCount(ctx context.Context, key, min, max string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zcount", key, min, max)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZLexCount(ctx context.Context, key, min, max string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zlexcount", key, min, max)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZIncrBy(ctx context.Context, key string, increment float64, member string) *FloatCmd {
+	cmd := NewFloatCmd(ctx, "zincrby", key, increment, member)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZInterStore(ctx context.Context, destination string, store *ZStore) *IntCmd {
+	args := make([]interface{}, 0, 3+store.len())
+	args = append(args, "zinterstore", destination, len(store.Keys))
+	args = store.appendArgs(args)
+	cmd := NewIntCmd(ctx, args...)
+	cmd.SetFirstKeyPos(3)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZInter(ctx context.Context, store *ZStore) *StringSliceCmd {
+	args := make([]interface{}, 0, 2+store.len())
+	args = append(args, "zinter", len(store.Keys))
+	args = store.appendArgs(args)
+	cmd := NewStringSliceCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZInterWithScores(ctx context.Context, store *ZStore) *ZSliceCmd {
+	args := make([]interface{}, 0, 3+store.len())
+	args = append(args, "zinter", len(store.Keys))
+	args = store.appendArgs(args)
+	args = append(args, "withscores")
+	cmd := NewZSliceCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZInterCard(ctx context.Context, limit int64, keys ...string) *IntCmd {
+	args := make([]interface{}, 4+len(keys))
+	args[0] = "zintercard"
+	numkeys := int64(0)
+	for i, key := range keys {
+		args[2+i] = key
+		numkeys++
+	}
+	args[1] = numkeys
+	args[2+numkeys] = "limit"
+	args[3+numkeys] = limit
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZMPop Pops one or more elements with the highest or lowest score from the first non-empty sorted set key from the list of provided key names.
+// direction: "max" (highest score) or "min" (lowest score), count: > 0
+// example: client.ZMPop(ctx, "max", 5, "set1", "set2")
+func (c cmdable) ZMPop(ctx context.Context, order string, count int64, keys ...string) *ZSliceWithKeyCmd {
+	args := make([]interface{}, 2+len(keys), 5+len(keys))
+	args[0] = "zmpop"
+	args[1] = len(keys)
+	for i, key := range keys {
+		args[2+i] = key
+	}
+	args = append(args, strings.ToLower(order), "count", count)
+	cmd := NewZSliceWithKeyCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZMScore(ctx context.Context, key string, members ...string) *FloatSliceCmd {
+	args := make([]interface{}, 2+len(members))
+	args[0] = "zmscore"
+	args[1] = key
+	for i, member := range members {
+		args[2+i] = member
+	}
+	cmd := NewFloatSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZPopMax(ctx context.Context, key string, count ...int64) *ZSliceCmd {
+	args := []interface{}{
+		"zpopmax",
+		key,
+	}
+
+	switch len(count) {
+	case 0:
+		break
+	case 1:
+		args = append(args, count[0])
+	default:
+		panic("too many arguments")
+	}
+
+	cmd := NewZSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZPopMin(ctx context.Context, key string, count ...int64) *ZSliceCmd {
+	args := []interface{}{
+		"zpopmin",
+		key,
+	}
+
+	switch len(count) {
+	case 0:
+		break
+	case 1:
+		args = append(args, count[0])
+	default:
+		panic("too many arguments")
+	}
+
+	cmd := NewZSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZRangeArgs is all the options of the ZRange command.
+// In version> 6.2.0, you can replace the(cmd):
+//
+//	ZREVRANGE,
+//	ZRANGEBYSCORE,
+//	ZREVRANGEBYSCORE,
+//	ZRANGEBYLEX,
+//	ZREVRANGEBYLEX.
+//
+// Please pay attention to your redis-server version.
+//
+// Rev, ByScore, ByLex and Offset+Count options require redis-server 6.2.0 and higher.
+type ZRangeArgs struct {
+	Key string
+
+	// When the ByScore option is provided, the open interval(exclusive) can be set.
+	// By default, the score intervals specified by <Start> and <Stop> are closed (inclusive).
+	// It is similar to the deprecated(6.2.0+) ZRangeByScore command.
+	// For example:
+	//		ZRangeArgs{
+	//			Key: 				"example-key",
+	//	 		Start: 				"(3",
+	//	 		Stop: 				8,
+	//			ByScore:			true,
+	//	 	}
+	// 	 	cmd: "ZRange example-key (3 8 ByScore"  (3 < score <= 8).
+	//
+	// For the ByLex option, it is similar to the deprecated(6.2.0+) ZRangeByLex command.
+	// You can set the <Start> and <Stop> options as follows:
+	//		ZRangeArgs{
+	//			Key: 				"example-key",
+	//	 		Start: 				"[abc",
+	//	 		Stop: 				"(def",
+	//			ByLex:				true,
+	//	 	}
+	//		cmd: "ZRange example-key [abc (def ByLex"
+	//
+	// For normal cases (ByScore==false && ByLex==false), <Start> and <Stop> should be set to the index range (int).
+	// You can read the documentation for more information: https://redis.io/commands/zrange
+	Start interface{}
+	Stop  interface{}
+
+	// The ByScore and ByLex options are mutually exclusive.
+	ByScore bool
+	ByLex   bool
+
+	Rev bool
+
+	// limit offset count.
+	Offset int64
+	Count  int64
+}
+
+func (z ZRangeArgs) appendArgs(args []interface{}) []interface{} {
+	// For Rev+ByScore/ByLex, we need to adjust the position of <Start> and <Stop>.
+	if z.Rev && (z.ByScore || z.ByLex) {
+		args = append(args, z.Key, z.Stop, z.Start)
+	} else {
+		args = append(args, z.Key, z.Start, z.Stop)
+	}
+
+	if z.ByScore {
+		args = append(args, "byscore")
+	} else if z.ByLex {
+		args = append(args, "bylex")
+	}
+	if z.Rev {
+		args = append(args, "rev")
+	}
+	if z.Offset != 0 || z.Count != 0 {
+		args = append(args, "limit", z.Offset, z.Count)
+	}
+	return args
+}
+
+func (c cmdable) ZRangeArgs(ctx context.Context, z ZRangeArgs) *StringSliceCmd {
+	args := make([]interface{}, 0, 9)
+	args = append(args, "zrange")
+	args = z.appendArgs(args)
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRangeArgsWithScores(ctx context.Context, z ZRangeArgs) *ZSliceCmd {
+	args := make([]interface{}, 0, 10)
+	args = append(args, "zrange")
+	args = z.appendArgs(args)
+	args = append(args, "withscores")
+	cmd := NewZSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
+	return c.ZRangeArgs(ctx, ZRangeArgs{
+		Key:   key,
+		Start: start,
+		Stop:  stop,
+	})
+}
+
+func (c cmdable) ZRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
+	return c.ZRangeArgsWithScores(ctx, ZRangeArgs{
+		Key:   key,
+		Start: start,
+		Stop:  stop,
+	})
+}
+
+type ZRangeBy struct {
+	Min, Max      string
+	Offset, Count int64
+}
+
+func (c cmdable) zRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy, withScores bool) *StringSliceCmd {
+	args := []interface{}{zcmd, key, opt.Min, opt.Max}
+	if withScores {
+		args = append(args, "withscores")
+	}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
+	return c.zRangeBy(ctx, "zrangebyscore", key, opt, false)
+}
+
+func (c cmdable) ZRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
+	return c.zRangeBy(ctx, "zrangebylex", key, opt, false)
+}
+
+func (c cmdable) ZRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
+	args := []interface{}{"zrangebyscore", key, opt.Min, opt.Max, "withscores"}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewZSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRangeStore(ctx context.Context, dst string, z ZRangeArgs) *IntCmd {
+	args := make([]interface{}, 0, 10)
+	args = append(args, "zrangestore", dst)
+	args = z.appendArgs(args)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRank(ctx context.Context, key, member string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zrank", key, member)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZRankWithScore according to the Redis documentation, if member does not exist
+// in the sorted set or key does not exist, it will return a redis.Nil error.
+func (c cmdable) ZRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd {
+	cmd := NewRankWithScoreCmd(ctx, "zrank", key, member, "withscore")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRem(ctx context.Context, key string, members ...interface{}) *IntCmd {
+	args := make([]interface{}, 2, 2+len(members))
+	args[0] = "zrem"
+	args[1] = key
+	args = appendArgs(args, members)
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRemRangeByRank(ctx context.Context, key string, start, stop int64) *IntCmd {
+	cmd := NewIntCmd(
+		ctx,
+		"zremrangebyrank",
+		key,
+		start,
+		stop,
+	)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRemRangeByScore(ctx context.Context, key, min, max string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zremrangebyscore", key, min, max)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRemRangeByLex(ctx context.Context, key, min, max string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zremrangebylex", key, min, max)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRevRange(ctx context.Context, key string, start, stop int64) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "zrevrange", key, start, stop)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZRevRangeWithScores according to the Redis documentation, if member does not exist
+// in the sorted set or key does not exist, it will return a redis.Nil error.
+func (c cmdable) ZRevRangeWithScores(ctx context.Context, key string, start, stop int64) *ZSliceCmd {
+	cmd := NewZSliceCmd(ctx, "zrevrange", key, start, stop, "withscores")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) zRevRangeBy(ctx context.Context, zcmd, key string, opt *ZRangeBy) *StringSliceCmd {
+	args := []interface{}{zcmd, key, opt.Max, opt.Min}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRevRangeByScore(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
+	return c.zRevRangeBy(ctx, "zrevrangebyscore", key, opt)
+}
+
+func (c cmdable) ZRevRangeByLex(ctx context.Context, key string, opt *ZRangeBy) *StringSliceCmd {
+	return c.zRevRangeBy(ctx, "zrevrangebylex", key, opt)
+}
+
+func (c cmdable) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *ZRangeBy) *ZSliceCmd {
+	args := []interface{}{"zrevrangebyscore", key, opt.Max, opt.Min, "withscores"}
+	if opt.Offset != 0 || opt.Count != 0 {
+		args = append(
+			args,
+			"limit",
+			opt.Offset,
+			opt.Count,
+		)
+	}
+	cmd := NewZSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRevRank(ctx context.Context, key, member string) *IntCmd {
+	cmd := NewIntCmd(ctx, "zrevrank", key, member)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZRevRankWithScore(ctx context.Context, key, member string) *RankWithScoreCmd {
+	cmd := NewRankWithScoreCmd(ctx, "zrevrank", key, member, "withscore")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZScore(ctx context.Context, key, member string) *FloatCmd {
+	cmd := NewFloatCmd(ctx, "zscore", key, member)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZUnion(ctx context.Context, store ZStore) *StringSliceCmd {
+	args := make([]interface{}, 0, 2+store.len())
+	args = append(args, "zunion", len(store.Keys))
+	args = store.appendArgs(args)
+	cmd := NewStringSliceCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZUnionWithScores(ctx context.Context, store ZStore) *ZSliceCmd {
+	args := make([]interface{}, 0, 3+store.len())
+	args = append(args, "zunion", len(store.Keys))
+	args = store.appendArgs(args)
+	args = append(args, "withscores")
+	cmd := NewZSliceCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZUnionStore(ctx context.Context, dest string, store *ZStore) *IntCmd {
+	args := make([]interface{}, 0, 3+store.len())
+	args = append(args, "zunionstore", dest, len(store.Keys))
+	args = store.appendArgs(args)
+	cmd := NewIntCmd(ctx, args...)
+	cmd.SetFirstKeyPos(3)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZRandMember redis-server version >= 6.2.0.
+func (c cmdable) ZRandMember(ctx context.Context, key string, count int) *StringSliceCmd {
+	cmd := NewStringSliceCmd(ctx, "zrandmember", key, count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZRandMemberWithScores redis-server version >= 6.2.0.
+func (c cmdable) ZRandMemberWithScores(ctx context.Context, key string, count int) *ZSliceCmd {
+	cmd := NewZSliceCmd(ctx, "zrandmember", key, count, "withscores")
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZDiff redis-server version >= 6.2.0.
+func (c cmdable) ZDiff(ctx context.Context, keys ...string) *StringSliceCmd {
+	args := make([]interface{}, 2+len(keys))
+	args[0] = "zdiff"
+	args[1] = len(keys)
+	for i, key := range keys {
+		args[i+2] = key
+	}
+
+	cmd := NewStringSliceCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZDiffWithScores redis-server version >= 6.2.0.
+func (c cmdable) ZDiffWithScores(ctx context.Context, keys ...string) *ZSliceCmd {
+	args := make([]interface{}, 3+len(keys))
+	args[0] = "zdiff"
+	args[1] = len(keys)
+	for i, key := range keys {
+		args[i+2] = key
+	}
+	args[len(keys)+2] = "withscores"
+
+	cmd := NewZSliceCmd(ctx, args...)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// ZDiffStore redis-server version >=6.2.0.
+func (c cmdable) ZDiffStore(ctx context.Context, destination string, keys ...string) *IntCmd {
+	args := make([]interface{}, 0, 3+len(keys))
+	args = append(args, "zdiffstore", destination, len(keys))
+	for _, key := range keys {
+		args = append(args, key)
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *ScanCmd {
+	args := []interface{}{"zscan", key, cursor}
+	if match != "" {
+		args = append(args, "match", match)
+	}
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewScanCmd(ctx, c, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// Z represents sorted set member.
+type Z struct {
+	Score  float64
+	Member interface{}
+}
+
+// ZWithKey represents sorted set member including the name of the key where it was popped.
+type ZWithKey struct {
+	Z
+	Key string
+}
+
+// ZStore is used as an arg to ZInter/ZInterStore and ZUnion/ZUnionStore.
+type ZStore struct {
+	Keys    []string
+	Weights []float64
+	// Can be SUM, MIN or MAX.
+	Aggregate string
+}
+
+func (z ZStore) len() (n int) {
+	n = len(z.Keys)
+	if len(z.Weights) > 0 {
+		n += 1 + len(z.Weights)
+	}
+	if z.Aggregate != "" {
+		n += 2
+	}
+	return n
+}
+
+func (z ZStore) appendArgs(args []interface{}) []interface{} {
+	for _, key := range z.Keys {
+		args = append(args, key)
+	}
+	if len(z.Weights) > 0 {
+		args = append(args, "weights")
+		for _, weights := range z.Weights {
+			args = append(args, weights)
+		}
+	}
+	if z.Aggregate != "" {
+		args = append(args, "aggregate", z.Aggregate)
+	}
+	return args
+}
diff --git a/stream_commands.go b/stream_commands.go
new file mode 100644
index 000000000..1ad33740c
--- /dev/null
+++ b/stream_commands.go
@@ -0,0 +1,444 @@
+package redis
+
+import (
+	"context"
+	"time"
+)
+
+type StreamCmdable interface {
+	XAdd(ctx context.Context, a *XAddArgs) *StringCmd
+	XDel(ctx context.Context, stream string, ids ...string) *IntCmd
+	XLen(ctx context.Context, stream string) *IntCmd
+	XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd
+	XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd
+	XRevRange(ctx context.Context, stream string, start, stop string) *XMessageSliceCmd
+	XRevRangeN(ctx context.Context, stream string, start, stop string, count int64) *XMessageSliceCmd
+	XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd
+	XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd
+	XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd
+	XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd
+	XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd
+	XGroupDestroy(ctx context.Context, stream, group string) *IntCmd
+	XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
+	XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd
+	XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd
+	XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd
+	XPending(ctx context.Context, stream, group string) *XPendingCmd
+	XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd
+	XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd
+	XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd
+	XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd
+	XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd
+	XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd
+	XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd
+	XTrimMinID(ctx context.Context, key string, minID string) *IntCmd
+	XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd
+	XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd
+	XInfoStream(ctx context.Context, key string) *XInfoStreamCmd
+	XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd
+	XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd
+}
+
+// XAddArgs accepts values in the following formats:
+//   - XAddArgs.Values = []interface{}{"key1", "value1", "key2", "value2"}
+//   - XAddArgs.Values = []string("key1", "value1", "key2", "value2")
+//   - XAddArgs.Values = map[string]interface{}{"key1": "value1", "key2": "value2"}
+//
+// Note that map will not preserve the order of key-value pairs.
+// MaxLen/MaxLenApprox and MinID are in conflict, only one of them can be used.
+type XAddArgs struct {
+	Stream     string
+	NoMkStream bool
+	MaxLen     int64 // MAXLEN N
+	MinID      string
+	// Approx causes MaxLen and MinID to use "~" matcher (instead of "=").
+	Approx bool
+	Limit  int64
+	ID     string
+	Values interface{}
+}
+
+func (c cmdable) XAdd(ctx context.Context, a *XAddArgs) *StringCmd {
+	args := make([]interface{}, 0, 11)
+	args = append(args, "xadd", a.Stream)
+	if a.NoMkStream {
+		args = append(args, "nomkstream")
+	}
+	switch {
+	case a.MaxLen > 0:
+		if a.Approx {
+			args = append(args, "maxlen", "~", a.MaxLen)
+		} else {
+			args = append(args, "maxlen", a.MaxLen)
+		}
+	case a.MinID != "":
+		if a.Approx {
+			args = append(args, "minid", "~", a.MinID)
+		} else {
+			args = append(args, "minid", a.MinID)
+		}
+	}
+	if a.Limit > 0 {
+		args = append(args, "limit", a.Limit)
+	}
+	if a.ID != "" {
+		args = append(args, a.ID)
+	} else {
+		args = append(args, "*")
+	}
+	args = appendArg(args, a.Values)
+
+	cmd := NewStringCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XDel(ctx context.Context, stream string, ids ...string) *IntCmd {
+	args := []interface{}{"xdel", stream}
+	for _, id := range ids {
+		args = append(args, id)
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XLen(ctx context.Context, stream string) *IntCmd {
+	cmd := NewIntCmd(ctx, "xlen", stream)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
+	cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
+	cmd := NewXMessageSliceCmd(ctx, "xrange", stream, start, stop, "count", count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XRevRange(ctx context.Context, stream, start, stop string) *XMessageSliceCmd {
+	cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XRevRangeN(ctx context.Context, stream, start, stop string, count int64) *XMessageSliceCmd {
+	cmd := NewXMessageSliceCmd(ctx, "xrevrange", stream, start, stop, "count", count)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type XReadArgs struct {
+	Streams []string // list of streams and ids, e.g. stream1 stream2 id1 id2
+	Count   int64
+	Block   time.Duration
+}
+
+func (c cmdable) XRead(ctx context.Context, a *XReadArgs) *XStreamSliceCmd {
+	args := make([]interface{}, 0, 6+len(a.Streams))
+	args = append(args, "xread")
+
+	keyPos := int8(1)
+	if a.Count > 0 {
+		args = append(args, "count")
+		args = append(args, a.Count)
+		keyPos += 2
+	}
+	if a.Block >= 0 {
+		args = append(args, "block")
+		args = append(args, int64(a.Block/time.Millisecond))
+		keyPos += 2
+	}
+	args = append(args, "streams")
+	keyPos++
+	for _, s := range a.Streams {
+		args = append(args, s)
+	}
+
+	cmd := NewXStreamSliceCmd(ctx, args...)
+	if a.Block >= 0 {
+		cmd.setReadTimeout(a.Block)
+	}
+	cmd.SetFirstKeyPos(keyPos)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XReadStreams(ctx context.Context, streams ...string) *XStreamSliceCmd {
+	return c.XRead(ctx, &XReadArgs{
+		Streams: streams,
+		Block:   -1,
+	})
+}
+
+func (c cmdable) XGroupCreate(ctx context.Context, stream, group, start string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XGroupCreateMkStream(ctx context.Context, stream, group, start string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "xgroup", "create", stream, group, start, "mkstream")
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XGroupSetID(ctx context.Context, stream, group, start string) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "xgroup", "setid", stream, group, start)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XGroupDestroy(ctx context.Context, stream, group string) *IntCmd {
+	cmd := NewIntCmd(ctx, "xgroup", "destroy", stream, group)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XGroupCreateConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
+	cmd := NewIntCmd(ctx, "xgroup", "createconsumer", stream, group, consumer)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XGroupDelConsumer(ctx context.Context, stream, group, consumer string) *IntCmd {
+	cmd := NewIntCmd(ctx, "xgroup", "delconsumer", stream, group, consumer)
+	cmd.SetFirstKeyPos(2)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type XReadGroupArgs struct {
+	Group    string
+	Consumer string
+	Streams  []string // list of streams and ids, e.g. stream1 stream2 id1 id2
+	Count    int64
+	Block    time.Duration
+	NoAck    bool
+}
+
+func (c cmdable) XReadGroup(ctx context.Context, a *XReadGroupArgs) *XStreamSliceCmd {
+	args := make([]interface{}, 0, 10+len(a.Streams))
+	args = append(args, "xreadgroup", "group", a.Group, a.Consumer)
+
+	keyPos := int8(4)
+	if a.Count > 0 {
+		args = append(args, "count", a.Count)
+		keyPos += 2
+	}
+	if a.Block >= 0 {
+		args = append(args, "block", int64(a.Block/time.Millisecond))
+		keyPos += 2
+	}
+	if a.NoAck {
+		args = append(args, "noack")
+		keyPos++
+	}
+	args = append(args, "streams")
+	keyPos++
+	for _, s := range a.Streams {
+		args = append(args, s)
+	}
+
+	cmd := NewXStreamSliceCmd(ctx, args...)
+	if a.Block >= 0 {
+		cmd.setReadTimeout(a.Block)
+	}
+	cmd.SetFirstKeyPos(keyPos)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XAck(ctx context.Context, stream, group string, ids ...string) *IntCmd {
+	args := []interface{}{"xack", stream, group}
+	for _, id := range ids {
+		args = append(args, id)
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XPending(ctx context.Context, stream, group string) *XPendingCmd {
+	cmd := NewXPendingCmd(ctx, "xpending", stream, group)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type XPendingExtArgs struct {
+	Stream   string
+	Group    string
+	Idle     time.Duration
+	Start    string
+	End      string
+	Count    int64
+	Consumer string
+}
+
+func (c cmdable) XPendingExt(ctx context.Context, a *XPendingExtArgs) *XPendingExtCmd {
+	args := make([]interface{}, 0, 9)
+	args = append(args, "xpending", a.Stream, a.Group)
+	if a.Idle != 0 {
+		args = append(args, "idle", formatMs(ctx, a.Idle))
+	}
+	args = append(args, a.Start, a.End, a.Count)
+	if a.Consumer != "" {
+		args = append(args, a.Consumer)
+	}
+	cmd := NewXPendingExtCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type XAutoClaimArgs struct {
+	Stream   string
+	Group    string
+	MinIdle  time.Duration
+	Start    string
+	Count    int64
+	Consumer string
+}
+
+func (c cmdable) XAutoClaim(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimCmd {
+	args := xAutoClaimArgs(ctx, a)
+	cmd := NewXAutoClaimCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XAutoClaimJustID(ctx context.Context, a *XAutoClaimArgs) *XAutoClaimJustIDCmd {
+	args := xAutoClaimArgs(ctx, a)
+	args = append(args, "justid")
+	cmd := NewXAutoClaimJustIDCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func xAutoClaimArgs(ctx context.Context, a *XAutoClaimArgs) []interface{} {
+	args := make([]interface{}, 0, 8)
+	args = append(args, "xautoclaim", a.Stream, a.Group, a.Consumer, formatMs(ctx, a.MinIdle), a.Start)
+	if a.Count > 0 {
+		args = append(args, "count", a.Count)
+	}
+	return args
+}
+
+type XClaimArgs struct {
+	Stream   string
+	Group    string
+	Consumer string
+	MinIdle  time.Duration
+	Messages []string
+}
+
+func (c cmdable) XClaim(ctx context.Context, a *XClaimArgs) *XMessageSliceCmd {
+	args := xClaimArgs(a)
+	cmd := NewXMessageSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XClaimJustID(ctx context.Context, a *XClaimArgs) *StringSliceCmd {
+	args := xClaimArgs(a)
+	args = append(args, "justid")
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func xClaimArgs(a *XClaimArgs) []interface{} {
+	args := make([]interface{}, 0, 5+len(a.Messages))
+	args = append(args,
+		"xclaim",
+		a.Stream,
+		a.Group, a.Consumer,
+		int64(a.MinIdle/time.Millisecond))
+	for _, id := range a.Messages {
+		args = append(args, id)
+	}
+	return args
+}
+
+// xTrim If approx is true, add the "~" parameter, otherwise it is the default "=" (redis default).
+// example:
+//
+//	XTRIM key MAXLEN/MINID threshold LIMIT limit.
+//	XTRIM key MAXLEN/MINID ~ threshold LIMIT limit.
+//
+// The redis-server version is lower than 6.2, please set limit to 0.
+func (c cmdable) xTrim(
+	ctx context.Context, key, strategy string,
+	approx bool, threshold interface{}, limit int64,
+) *IntCmd {
+	args := make([]interface{}, 0, 7)
+	args = append(args, "xtrim", key, strategy)
+	if approx {
+		args = append(args, "~")
+	}
+	args = append(args, threshold)
+	if limit > 0 {
+		args = append(args, "limit", limit)
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// XTrimMaxLen No `~` rules are used, `limit` cannot be used.
+// cmd: XTRIM key MAXLEN maxLen
+func (c cmdable) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *IntCmd {
+	return c.xTrim(ctx, key, "maxlen", false, maxLen, 0)
+}
+
+func (c cmdable) XTrimMaxLenApprox(ctx context.Context, key string, maxLen, limit int64) *IntCmd {
+	return c.xTrim(ctx, key, "maxlen", true, maxLen, limit)
+}
+
+func (c cmdable) XTrimMinID(ctx context.Context, key string, minID string) *IntCmd {
+	return c.xTrim(ctx, key, "minid", false, minID, 0)
+}
+
+func (c cmdable) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *IntCmd {
+	return c.xTrim(ctx, key, "minid", true, minID, limit)
+}
+
+func (c cmdable) XInfoConsumers(ctx context.Context, key string, group string) *XInfoConsumersCmd {
+	cmd := NewXInfoConsumersCmd(ctx, key, group)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XInfoGroups(ctx context.Context, key string) *XInfoGroupsCmd {
+	cmd := NewXInfoGroupsCmd(ctx, key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) XInfoStream(ctx context.Context, key string) *XInfoStreamCmd {
+	cmd := NewXInfoStreamCmd(ctx, key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// XInfoStreamFull XINFO STREAM FULL [COUNT count]
+// redis-server >= 6.0.
+func (c cmdable) XInfoStreamFull(ctx context.Context, key string, count int) *XInfoStreamFullCmd {
+	args := make([]interface{}, 0, 6)
+	args = append(args, "xinfo", "stream", key, "full")
+	if count > 0 {
+		args = append(args, "count", count)
+	}
+	cmd := NewXInfoStreamFullCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/string_commands.go b/string_commands.go
new file mode 100644
index 000000000..eff5880dc
--- /dev/null
+++ b/string_commands.go
@@ -0,0 +1,303 @@
+package redis
+
+import (
+	"context"
+	"time"
+)
+
+type StringCmdable interface {
+	Append(ctx context.Context, key, value string) *IntCmd
+	Decr(ctx context.Context, key string) *IntCmd
+	DecrBy(ctx context.Context, key string, decrement int64) *IntCmd
+	Get(ctx context.Context, key string) *StringCmd
+	GetRange(ctx context.Context, key string, start, end int64) *StringCmd
+	GetSet(ctx context.Context, key string, value interface{}) *StringCmd
+	GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd
+	GetDel(ctx context.Context, key string) *StringCmd
+	Incr(ctx context.Context, key string) *IntCmd
+	IncrBy(ctx context.Context, key string, value int64) *IntCmd
+	IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd
+	LCS(ctx context.Context, q *LCSQuery) *LCSCmd
+	MGet(ctx context.Context, keys ...string) *SliceCmd
+	MSet(ctx context.Context, values ...interface{}) *StatusCmd
+	MSetNX(ctx context.Context, values ...interface{}) *BoolCmd
+	Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
+	SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd
+	SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd
+	SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
+	SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd
+	SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd
+	StrLen(ctx context.Context, key string) *IntCmd
+}
+
+func (c cmdable) Append(ctx context.Context, key, value string) *IntCmd {
+	cmd := NewIntCmd(ctx, "append", key, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Decr(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "decr", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) DecrBy(ctx context.Context, key string, decrement int64) *IntCmd {
+	cmd := NewIntCmd(ctx, "decrby", key, decrement)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// Get Redis `GET key` command. It returns redis.Nil error when key does not exist.
+func (c cmdable) Get(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "get", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GetRange(ctx context.Context, key string, start, end int64) *StringCmd {
+	cmd := NewStringCmd(ctx, "getrange", key, start, end)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) GetSet(ctx context.Context, key string, value interface{}) *StringCmd {
+	cmd := NewStringCmd(ctx, "getset", key, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// GetEx An expiration of zero removes the TTL associated with the key (i.e. GETEX key persist).
+// Requires Redis >= 6.2.0.
+func (c cmdable) GetEx(ctx context.Context, key string, expiration time.Duration) *StringCmd {
+	args := make([]interface{}, 0, 4)
+	args = append(args, "getex", key)
+	if expiration > 0 {
+		if usePrecise(expiration) {
+			args = append(args, "px", formatMs(ctx, expiration))
+		} else {
+			args = append(args, "ex", formatSec(ctx, expiration))
+		}
+	} else if expiration == 0 {
+		args = append(args, "persist")
+	}
+
+	cmd := NewStringCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// GetDel redis-server version >= 6.2.0.
+func (c cmdable) GetDel(ctx context.Context, key string) *StringCmd {
+	cmd := NewStringCmd(ctx, "getdel", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) Incr(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "incr", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) IncrBy(ctx context.Context, key string, value int64) *IntCmd {
+	cmd := NewIntCmd(ctx, "incrby", key, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) IncrByFloat(ctx context.Context, key string, value float64) *FloatCmd {
+	cmd := NewFloatCmd(ctx, "incrbyfloat", key, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) LCS(ctx context.Context, q *LCSQuery) *LCSCmd {
+	cmd := NewLCSCmd(ctx, q)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) MGet(ctx context.Context, keys ...string) *SliceCmd {
+	args := make([]interface{}, 1+len(keys))
+	args[0] = "mget"
+	for i, key := range keys {
+		args[1+i] = key
+	}
+	cmd := NewSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// MSet is like Set but accepts multiple values:
+//   - MSet("key1", "value1", "key2", "value2")
+//   - MSet([]string{"key1", "value1", "key2", "value2"})
+//   - MSet(map[string]interface{}{"key1": "value1", "key2": "value2"})
+//   - MSet(struct), For struct types, see HSet description.
+func (c cmdable) MSet(ctx context.Context, values ...interface{}) *StatusCmd {
+	args := make([]interface{}, 1, 1+len(values))
+	args[0] = "mset"
+	args = appendArgs(args, values)
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// MSetNX is like SetNX but accepts multiple values:
+//   - MSetNX("key1", "value1", "key2", "value2")
+//   - MSetNX([]string{"key1", "value1", "key2", "value2"})
+//   - MSetNX(map[string]interface{}{"key1": "value1", "key2": "value2"})
+//   - MSetNX(struct), For struct types, see HSet description.
+func (c cmdable) MSetNX(ctx context.Context, values ...interface{}) *BoolCmd {
+	args := make([]interface{}, 1, 1+len(values))
+	args[0] = "msetnx"
+	args = appendArgs(args, values)
+	cmd := NewBoolCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// Set Redis `SET key value [expiration]` command.
+// Use expiration for `SETEx`-like behavior.
+//
+// Zero expiration means the key has no expiration time.
+// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
+// otherwise you will receive an error: (error) ERR syntax error.
+func (c cmdable) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
+	args := make([]interface{}, 3, 5)
+	args[0] = "set"
+	args[1] = key
+	args[2] = value
+	if expiration > 0 {
+		if usePrecise(expiration) {
+			args = append(args, "px", formatMs(ctx, expiration))
+		} else {
+			args = append(args, "ex", formatSec(ctx, expiration))
+		}
+	} else if expiration == KeepTTL {
+		args = append(args, "keepttl")
+	}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SetArgs provides arguments for the SetArgs function.
+type SetArgs struct {
+	// Mode can be `NX` or `XX` or empty.
+	Mode string
+
+	// Zero `TTL` or `Expiration` means that the key has no expiration time.
+	TTL      time.Duration
+	ExpireAt time.Time
+
+	// When Get is true, the command returns the old value stored at key, or nil when key did not exist.
+	Get bool
+
+	// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
+	// otherwise you will receive an error: (error) ERR syntax error.
+	KeepTTL bool
+}
+
+// SetArgs supports all the options that the SET command supports.
+// It is the alternative to the Set function when you want
+// to have more control over the options.
+func (c cmdable) SetArgs(ctx context.Context, key string, value interface{}, a SetArgs) *StatusCmd {
+	args := []interface{}{"set", key, value}
+
+	if a.KeepTTL {
+		args = append(args, "keepttl")
+	}
+
+	if !a.ExpireAt.IsZero() {
+		args = append(args, "exat", a.ExpireAt.Unix())
+	}
+	if a.TTL > 0 {
+		if usePrecise(a.TTL) {
+			args = append(args, "px", formatMs(ctx, a.TTL))
+		} else {
+			args = append(args, "ex", formatSec(ctx, a.TTL))
+		}
+	}
+
+	if a.Mode != "" {
+		args = append(args, a.Mode)
+	}
+
+	if a.Get {
+		args = append(args, "get")
+	}
+
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SetEx Redis `SETEx key expiration value` command.
+func (c cmdable) SetEx(ctx context.Context, key string, value interface{}, expiration time.Duration) *StatusCmd {
+	cmd := NewStatusCmd(ctx, "setex", key, formatSec(ctx, expiration), value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SetNX Redis `SET key value [expiration] NX` command.
+//
+// Zero expiration means the key has no expiration time.
+// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
+// otherwise you will receive an error: (error) ERR syntax error.
+func (c cmdable) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
+	var cmd *BoolCmd
+	switch expiration {
+	case 0:
+		// Use old `SETNX` to support old Redis versions.
+		cmd = NewBoolCmd(ctx, "setnx", key, value)
+	case KeepTTL:
+		cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "nx")
+	default:
+		if usePrecise(expiration) {
+			cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "nx")
+		} else {
+			cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "nx")
+		}
+	}
+
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// SetXX Redis `SET key value [expiration] XX` command.
+//
+// Zero expiration means the key has no expiration time.
+// KeepTTL is a Redis KEEPTTL option to keep existing TTL, it requires your redis-server version >= 6.0,
+// otherwise you will receive an error: (error) ERR syntax error.
+func (c cmdable) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *BoolCmd {
+	var cmd *BoolCmd
+	switch expiration {
+	case 0:
+		cmd = NewBoolCmd(ctx, "set", key, value, "xx")
+	case KeepTTL:
+		cmd = NewBoolCmd(ctx, "set", key, value, "keepttl", "xx")
+	default:
+		if usePrecise(expiration) {
+			cmd = NewBoolCmd(ctx, "set", key, value, "px", formatMs(ctx, expiration), "xx")
+		} else {
+			cmd = NewBoolCmd(ctx, "set", key, value, "ex", formatSec(ctx, expiration), "xx")
+		}
+	}
+
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) SetRange(ctx context.Context, key string, offset int64, value string) *IntCmd {
+	cmd := NewIntCmd(ctx, "setrange", key, offset, value)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+func (c cmdable) StrLen(ctx context.Context, key string) *IntCmd {
+	cmd := NewIntCmd(ctx, "strlen", key)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/timeseries_commands.go b/timeseries_commands.go
new file mode 100644
index 000000000..6f1b2fa45
--- /dev/null
+++ b/timeseries_commands.go
@@ -0,0 +1,922 @@
+package redis
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/redis/go-redis/v9/internal/proto"
+)
+
+type TimeseriesCmdable interface {
+	TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *IntCmd
+	TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *TSOptions) *IntCmd
+	TSCreate(ctx context.Context, key string) *StatusCmd
+	TSCreateWithArgs(ctx context.Context, key string, options *TSOptions) *StatusCmd
+	TSAlter(ctx context.Context, key string, options *TSAlterOptions) *StatusCmd
+	TSCreateRule(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int) *StatusCmd
+	TSCreateRuleWithArgs(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int, options *TSCreateRuleOptions) *StatusCmd
+	TSIncrBy(ctx context.Context, Key string, timestamp float64) *IntCmd
+	TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd
+	TSDecrBy(ctx context.Context, Key string, timestamp float64) *IntCmd
+	TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd
+	TSDel(ctx context.Context, Key string, fromTimestamp int, toTimestamp int) *IntCmd
+	TSDeleteRule(ctx context.Context, sourceKey string, destKey string) *StatusCmd
+	TSGet(ctx context.Context, key string) *TSTimestampValueCmd
+	TSGetWithArgs(ctx context.Context, key string, options *TSGetOptions) *TSTimestampValueCmd
+	TSInfo(ctx context.Context, key string) *MapStringInterfaceCmd
+	TSInfoWithArgs(ctx context.Context, key string, options *TSInfoOptions) *MapStringInterfaceCmd
+	TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *IntSliceCmd
+	TSQueryIndex(ctx context.Context, filterExpr []string) *StringSliceCmd
+	TSRevRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd
+	TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRevRangeOptions) *TSTimestampValueSliceCmd
+	TSRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd
+	TSRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRangeOptions) *TSTimestampValueSliceCmd
+	TSMRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd
+	TSMRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRangeOptions) *MapStringSliceInterfaceCmd
+	TSMRevRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd
+	TSMRevRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRevRangeOptions) *MapStringSliceInterfaceCmd
+	TSMGet(ctx context.Context, filters []string) *MapStringSliceInterfaceCmd
+	TSMGetWithArgs(ctx context.Context, filters []string, options *TSMGetOptions) *MapStringSliceInterfaceCmd
+}
+
+type TSOptions struct {
+	Retention       int
+	ChunkSize       int
+	Encoding        string
+	DuplicatePolicy string
+	Labels          map[string]string
+}
+type TSIncrDecrOptions struct {
+	Timestamp    int64
+	Retention    int
+	ChunkSize    int
+	Uncompressed bool
+	Labels       map[string]string
+}
+
+type TSAlterOptions struct {
+	Retention       int
+	ChunkSize       int
+	DuplicatePolicy string
+	Labels          map[string]string
+}
+
+type TSCreateRuleOptions struct {
+	alignTimestamp int64
+}
+
+type TSGetOptions struct {
+	Latest bool
+}
+
+type TSInfoOptions struct {
+	Debug bool
+}
+type Aggregator int
+
+const (
+	Invalid = Aggregator(iota)
+	Avg
+	Sum
+	Min
+	Max
+	Range
+	Count
+	First
+	Last
+	StdP
+	StdS
+	VarP
+	VarS
+	Twa
+)
+
+func (a Aggregator) String() string {
+	switch a {
+	case Invalid:
+		return ""
+	case Avg:
+		return "AVG"
+	case Sum:
+		return "SUM"
+	case Min:
+		return "MIN"
+	case Max:
+		return "MAX"
+	case Range:
+		return "RANGE"
+	case Count:
+		return "COUNT"
+	case First:
+		return "FIRST"
+	case Last:
+		return "LAST"
+	case StdP:
+		return "STD.P"
+	case StdS:
+		return "STD.S"
+	case VarP:
+		return "VAR.P"
+	case VarS:
+		return "VAR.S"
+	case Twa:
+		return "TWA"
+	default:
+		return ""
+	}
+}
+
+type TSRangeOptions struct {
+	Latest          bool
+	FilterByTS      []int
+	FilterByValue   []int
+	Count           int
+	Align           interface{}
+	Aggregator      Aggregator
+	BucketDuration  int
+	BucketTimestamp interface{}
+	Empty           bool
+}
+
+type TSRevRangeOptions struct {
+	Latest          bool
+	FilterByTS      []int
+	FilterByValue   []int
+	Count           int
+	Align           interface{}
+	Aggregator      Aggregator
+	BucketDuration  int
+	BucketTimestamp interface{}
+	Empty           bool
+}
+
+type TSMRangeOptions struct {
+	Latest          bool
+	FilterByTS      []int
+	FilterByValue   []int
+	WithLabels      bool
+	SelectedLabels  []interface{}
+	Count           int
+	Align           interface{}
+	Aggregator      Aggregator
+	BucketDuration  int
+	BucketTimestamp interface{}
+	Empty           bool
+	GroupByLabel    interface{}
+	Reducer         interface{}
+}
+
+type TSMRevRangeOptions struct {
+	Latest          bool
+	FilterByTS      []int
+	FilterByValue   []int
+	WithLabels      bool
+	SelectedLabels  []interface{}
+	Count           int
+	Align           interface{}
+	Aggregator      Aggregator
+	BucketDuration  int
+	BucketTimestamp interface{}
+	Empty           bool
+	GroupByLabel    interface{}
+	Reducer         interface{}
+}
+
+type TSMGetOptions struct {
+	Latest         bool
+	WithLabels     bool
+	SelectedLabels []interface{}
+}
+
+// TSAdd - Adds one or more observations to a t-digest sketch.
+// For more information - https://redis.io/commands/ts.add/
+func (c cmdable) TSAdd(ctx context.Context, key string, timestamp interface{}, value float64) *IntCmd {
+	args := []interface{}{"TS.ADD", key, timestamp, value}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSAddWithArgs - Adds one or more observations to a t-digest sketch.
+// This function also allows for specifying additional options such as:
+// Retention, ChunkSize, Encoding, DuplicatePolicy and Labels.
+// For more information - https://redis.io/commands/ts.add/
+func (c cmdable) TSAddWithArgs(ctx context.Context, key string, timestamp interface{}, value float64, options *TSOptions) *IntCmd {
+	args := []interface{}{"TS.ADD", key, timestamp, value}
+	if options != nil {
+		if options.Retention != 0 {
+			args = append(args, "RETENTION", options.Retention)
+		}
+		if options.ChunkSize != 0 {
+			args = append(args, "CHUNK_SIZE", options.ChunkSize)
+		}
+		if options.Encoding != "" {
+			args = append(args, "ENCODING", options.Encoding)
+		}
+
+		if options.DuplicatePolicy != "" {
+			args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
+		}
+		if options.Labels != nil {
+			args = append(args, "LABELS")
+			for label, value := range options.Labels {
+				args = append(args, label, value)
+			}
+		}
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSCreate - Creates a new time-series key.
+// For more information - https://redis.io/commands/ts.create/
+func (c cmdable) TSCreate(ctx context.Context, key string) *StatusCmd {
+	args := []interface{}{"TS.CREATE", key}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSCreateWithArgs - Creates a new time-series key with additional options.
+// This function allows for specifying additional options such as:
+// Retention, ChunkSize, Encoding, DuplicatePolicy and Labels.
+// For more information - https://redis.io/commands/ts.create/
+func (c cmdable) TSCreateWithArgs(ctx context.Context, key string, options *TSOptions) *StatusCmd {
+	args := []interface{}{"TS.CREATE", key}
+	if options != nil {
+		if options.Retention != 0 {
+			args = append(args, "RETENTION", options.Retention)
+		}
+		if options.ChunkSize != 0 {
+			args = append(args, "CHUNK_SIZE", options.ChunkSize)
+		}
+		if options.Encoding != "" {
+			args = append(args, "ENCODING", options.Encoding)
+		}
+
+		if options.DuplicatePolicy != "" {
+			args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
+		}
+		if options.Labels != nil {
+			args = append(args, "LABELS")
+			for label, value := range options.Labels {
+				args = append(args, label, value)
+			}
+		}
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSAlter - Alters an existing time-series key with additional options.
+// This function allows for specifying additional options such as:
+// Retention, ChunkSize and DuplicatePolicy.
+// For more information - https://redis.io/commands/ts.alter/
+func (c cmdable) TSAlter(ctx context.Context, key string, options *TSAlterOptions) *StatusCmd {
+	args := []interface{}{"TS.ALTER", key}
+	if options != nil {
+		if options.Retention != 0 {
+			args = append(args, "RETENTION", options.Retention)
+		}
+		if options.ChunkSize != 0 {
+			args = append(args, "CHUNK_SIZE", options.ChunkSize)
+		}
+		if options.DuplicatePolicy != "" {
+			args = append(args, "DUPLICATE_POLICY", options.DuplicatePolicy)
+		}
+		if options.Labels != nil {
+			args = append(args, "LABELS")
+			for label, value := range options.Labels {
+				args = append(args, label, value)
+			}
+		}
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSCreateRule - Creates a compaction rule from sourceKey to destKey.
+// For more information - https://redis.io/commands/ts.createrule/
+func (c cmdable) TSCreateRule(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int) *StatusCmd {
+	args := []interface{}{"TS.CREATERULE", sourceKey, destKey, "AGGREGATION", aggregator.String(), bucketDuration}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSCreateRuleWithArgs - Creates a compaction rule from sourceKey to destKey with additional option.
+// This function allows for specifying additional option such as:
+// alignTimestamp.
+// For more information - https://redis.io/commands/ts.createrule/
+func (c cmdable) TSCreateRuleWithArgs(ctx context.Context, sourceKey string, destKey string, aggregator Aggregator, bucketDuration int, options *TSCreateRuleOptions) *StatusCmd {
+	args := []interface{}{"TS.CREATERULE", sourceKey, destKey, "AGGREGATION", aggregator.String(), bucketDuration}
+	if options != nil {
+		if options.alignTimestamp != 0 {
+			args = append(args, options.alignTimestamp)
+		}
+	}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSIncrBy - Increments the value of a time-series key by the specified timestamp.
+// For more information - https://redis.io/commands/ts.incrby/
+func (c cmdable) TSIncrBy(ctx context.Context, Key string, timestamp float64) *IntCmd {
+	args := []interface{}{"TS.INCRBY", Key, timestamp}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSIncrByWithArgs - Increments the value of a time-series key by the specified timestamp with additional options.
+// This function allows for specifying additional options such as:
+// Timestamp, Retention, ChunkSize, Uncompressed and Labels.
+// For more information - https://redis.io/commands/ts.incrby/
+func (c cmdable) TSIncrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd {
+	args := []interface{}{"TS.INCRBY", key, timestamp}
+	if options != nil {
+		if options.Timestamp != 0 {
+			args = append(args, "TIMESTAMP", options.Timestamp)
+		}
+		if options.Retention != 0 {
+			args = append(args, "RETENTION", options.Retention)
+		}
+		if options.ChunkSize != 0 {
+			args = append(args, "CHUNK_SIZE", options.ChunkSize)
+		}
+		if options.Uncompressed {
+			args = append(args, "UNCOMPRESSED")
+		}
+		if options.Labels != nil {
+			args = append(args, "LABELS")
+			for label, value := range options.Labels {
+				args = append(args, label, value)
+			}
+		}
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSDecrBy - Decrements the value of a time-series key by the specified timestamp.
+// For more information - https://redis.io/commands/ts.decrby/
+func (c cmdable) TSDecrBy(ctx context.Context, Key string, timestamp float64) *IntCmd {
+	args := []interface{}{"TS.DECRBY", Key, timestamp}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSDecrByWithArgs - Decrements the value of a time-series key by the specified timestamp with additional options.
+// This function allows for specifying additional options such as:
+// Timestamp, Retention, ChunkSize, Uncompressed and Labels.
+// For more information - https://redis.io/commands/ts.decrby/
+func (c cmdable) TSDecrByWithArgs(ctx context.Context, key string, timestamp float64, options *TSIncrDecrOptions) *IntCmd {
+	args := []interface{}{"TS.DECRBY", key, timestamp}
+	if options != nil {
+		if options.Timestamp != 0 {
+			args = append(args, "TIMESTAMP", options.Timestamp)
+		}
+		if options.Retention != 0 {
+			args = append(args, "RETENTION", options.Retention)
+		}
+		if options.ChunkSize != 0 {
+			args = append(args, "CHUNK_SIZE", options.ChunkSize)
+		}
+		if options.Uncompressed {
+			args = append(args, "UNCOMPRESSED")
+		}
+		if options.Labels != nil {
+			args = append(args, "LABELS")
+			for label, value := range options.Labels {
+				args = append(args, label, value)
+			}
+		}
+	}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSDel - Deletes a range of samples from a time-series key.
+// For more information - https://redis.io/commands/ts.del/
+func (c cmdable) TSDel(ctx context.Context, Key string, fromTimestamp int, toTimestamp int) *IntCmd {
+	args := []interface{}{"TS.DEL", Key, fromTimestamp, toTimestamp}
+	cmd := NewIntCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSDeleteRule - Deletes a compaction rule from sourceKey to destKey.
+// For more information - https://redis.io/commands/ts.deleterule/
+func (c cmdable) TSDeleteRule(ctx context.Context, sourceKey string, destKey string) *StatusCmd {
+	args := []interface{}{"TS.DELETERULE", sourceKey, destKey}
+	cmd := NewStatusCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSGetWithArgs - Gets the last sample of a time-series key with additional option.
+// This function allows for specifying additional option such as:
+// Latest.
+// For more information - https://redis.io/commands/ts.get/
+func (c cmdable) TSGetWithArgs(ctx context.Context, key string, options *TSGetOptions) *TSTimestampValueCmd {
+	args := []interface{}{"TS.GET", key}
+	if options != nil {
+		if options.Latest {
+			args = append(args, "LATEST")
+		}
+	}
+	cmd := newTSTimestampValueCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSGet - Gets the last sample of a time-series key.
+// For more information - https://redis.io/commands/ts.get/
+func (c cmdable) TSGet(ctx context.Context, key string) *TSTimestampValueCmd {
+	args := []interface{}{"TS.GET", key}
+	cmd := newTSTimestampValueCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type TSTimestampValue struct {
+	Timestamp int64
+	Value     float64
+}
+type TSTimestampValueCmd struct {
+	baseCmd
+	val TSTimestampValue
+}
+
+func newTSTimestampValueCmd(ctx context.Context, args ...interface{}) *TSTimestampValueCmd {
+	return &TSTimestampValueCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *TSTimestampValueCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *TSTimestampValueCmd) SetVal(val TSTimestampValue) {
+	cmd.val = val
+}
+
+func (cmd *TSTimestampValueCmd) Result() (TSTimestampValue, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *TSTimestampValueCmd) Val() TSTimestampValue {
+	return cmd.val
+}
+
+func (cmd *TSTimestampValueCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadMapLen()
+	if err != nil {
+		return err
+	}
+	cmd.val = TSTimestampValue{}
+	for i := 0; i < n; i++ {
+		timestamp, err := rd.ReadInt()
+		if err != nil {
+			return err
+		}
+		value, err := rd.ReadString()
+		if err != nil {
+			return err
+		}
+		cmd.val.Timestamp = timestamp
+		cmd.val.Value, err = strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// TSInfo - Returns information about a time-series key.
+// For more information - https://redis.io/commands/ts.info/
+func (c cmdable) TSInfo(ctx context.Context, key string) *MapStringInterfaceCmd {
+	args := []interface{}{"TS.INFO", key}
+	cmd := NewMapStringInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSInfoWithArgs - Returns information about a time-series key with additional option.
+// This function allows for specifying additional option such as:
+// Debug.
+// For more information - https://redis.io/commands/ts.info/
+func (c cmdable) TSInfoWithArgs(ctx context.Context, key string, options *TSInfoOptions) *MapStringInterfaceCmd {
+	args := []interface{}{"TS.INFO", key}
+	if options != nil {
+		if options.Debug {
+			args = append(args, "DEBUG")
+		}
+	}
+	cmd := NewMapStringInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSMAdd - Adds multiple samples to multiple time-series keys.
+// It accepts a slice of 'ktv' slices, each containing exactly three elements: key, timestamp, and value.
+// This struct must be provided for this command to work.
+// For more information - https://redis.io/commands/ts.madd/
+func (c cmdable) TSMAdd(ctx context.Context, ktvSlices [][]interface{}) *IntSliceCmd {
+	args := []interface{}{"TS.MADD"}
+	for _, ktv := range ktvSlices {
+		args = append(args, ktv...)
+	}
+	cmd := NewIntSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSQueryIndex - Returns all the keys matching the filter expression.
+// For more information - https://redis.io/commands/ts.queryindex/
+func (c cmdable) TSQueryIndex(ctx context.Context, filterExpr []string) *StringSliceCmd {
+	args := []interface{}{"TS.QUERYINDEX"}
+	for _, f := range filterExpr {
+		args = append(args, f)
+	}
+	cmd := NewStringSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSRevRange - Returns a range of samples from a time-series key in reverse order.
+// For more information - https://redis.io/commands/ts.revrange/
+func (c cmdable) TSRevRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd {
+	args := []interface{}{"TS.REVRANGE", key, fromTimestamp, toTimestamp}
+	cmd := newTSTimestampValueSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSRevRangeWithArgs - Returns a range of samples from a time-series key in reverse order with additional options.
+// This function allows for specifying additional options such as:
+// Latest, FilterByTS, FilterByValue, Count, Align, Aggregator,
+// BucketDuration, BucketTimestamp and Empty.
+// For more information - https://redis.io/commands/ts.revrange/
+func (c cmdable) TSRevRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRevRangeOptions) *TSTimestampValueSliceCmd {
+	args := []interface{}{"TS.REVRANGE", key, fromTimestamp, toTimestamp}
+	if options != nil {
+		if options.Latest {
+			args = append(args, "LATEST")
+		}
+		if options.FilterByTS != nil {
+			args = append(args, "FILTER_BY_TS")
+			for _, f := range options.FilterByTS {
+				args = append(args, f)
+			}
+		}
+		if options.FilterByValue != nil {
+			args = append(args, "FILTER_BY_VALUE")
+			for _, f := range options.FilterByValue {
+				args = append(args, f)
+			}
+		}
+		if options.Count != 0 {
+			args = append(args, "COUNT", options.Count)
+		}
+		if options.Align != nil {
+			args = append(args, "ALIGN", options.Align)
+		}
+		if options.Aggregator != 0 {
+			args = append(args, "AGGREGATION", options.Aggregator.String())
+		}
+		if options.BucketDuration != 0 {
+			args = append(args, options.BucketDuration)
+		}
+		if options.BucketTimestamp != nil {
+			args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
+		}
+		if options.Empty {
+			args = append(args, "EMPTY")
+		}
+	}
+	cmd := newTSTimestampValueSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSRange - Returns a range of samples from a time-series key.
+// For more information - https://redis.io/commands/ts.range/
+func (c cmdable) TSRange(ctx context.Context, key string, fromTimestamp int, toTimestamp int) *TSTimestampValueSliceCmd {
+	args := []interface{}{"TS.RANGE", key, fromTimestamp, toTimestamp}
+	cmd := newTSTimestampValueSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSRangeWithArgs - Returns a range of samples from a time-series key with additional options.
+// This function allows for specifying additional options such as:
+// Latest, FilterByTS, FilterByValue, Count, Align, Aggregator,
+// BucketDuration, BucketTimestamp and Empty.
+// For more information - https://redis.io/commands/ts.range/
+func (c cmdable) TSRangeWithArgs(ctx context.Context, key string, fromTimestamp int, toTimestamp int, options *TSRangeOptions) *TSTimestampValueSliceCmd {
+	args := []interface{}{"TS.RANGE", key, fromTimestamp, toTimestamp}
+	if options != nil {
+		if options.Latest {
+			args = append(args, "LATEST")
+		}
+		if options.FilterByTS != nil {
+			args = append(args, "FILTER_BY_TS")
+			for _, f := range options.FilterByTS {
+				args = append(args, f)
+			}
+		}
+		if options.FilterByValue != nil {
+			args = append(args, "FILTER_BY_VALUE")
+			for _, f := range options.FilterByValue {
+				args = append(args, f)
+			}
+		}
+		if options.Count != 0 {
+			args = append(args, "COUNT", options.Count)
+		}
+		if options.Align != nil {
+			args = append(args, "ALIGN", options.Align)
+		}
+		if options.Aggregator != 0 {
+			args = append(args, "AGGREGATION", options.Aggregator.String())
+		}
+		if options.BucketDuration != 0 {
+			args = append(args, options.BucketDuration)
+		}
+		if options.BucketTimestamp != nil {
+			args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
+		}
+		if options.Empty {
+			args = append(args, "EMPTY")
+		}
+	}
+	cmd := newTSTimestampValueSliceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+type TSTimestampValueSliceCmd struct {
+	baseCmd
+	val []TSTimestampValue
+}
+
+func newTSTimestampValueSliceCmd(ctx context.Context, args ...interface{}) *TSTimestampValueSliceCmd {
+	return &TSTimestampValueSliceCmd{
+		baseCmd: baseCmd{
+			ctx:  ctx,
+			args: args,
+		},
+	}
+}
+
+func (cmd *TSTimestampValueSliceCmd) String() string {
+	return cmdString(cmd, cmd.val)
+}
+
+func (cmd *TSTimestampValueSliceCmd) SetVal(val []TSTimestampValue) {
+	cmd.val = val
+}
+
+func (cmd *TSTimestampValueSliceCmd) Result() ([]TSTimestampValue, error) {
+	return cmd.val, cmd.err
+}
+
+func (cmd *TSTimestampValueSliceCmd) Val() []TSTimestampValue {
+	return cmd.val
+}
+
+func (cmd *TSTimestampValueSliceCmd) readReply(rd *proto.Reader) (err error) {
+	n, err := rd.ReadArrayLen()
+	if err != nil {
+		return err
+	}
+	cmd.val = make([]TSTimestampValue, n)
+	for i := 0; i < n; i++ {
+		_, _ = rd.ReadArrayLen()
+		timestamp, err := rd.ReadInt()
+		if err != nil {
+			return err
+		}
+		value, err := rd.ReadString()
+		if err != nil {
+			return err
+		}
+		cmd.val[i].Timestamp = timestamp
+		cmd.val[i].Value, err = strconv.ParseFloat(value, 64)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// TSMRange - Returns a range of samples from multiple time-series keys.
+// For more information - https://redis.io/commands/ts.mrange/
+func (c cmdable) TSMRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd {
+	args := []interface{}{"TS.MRANGE", fromTimestamp, toTimestamp, "FILTER"}
+	for _, f := range filterExpr {
+		args = append(args, f)
+	}
+	cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSMRangeWithArgs - Returns a range of samples from multiple time-series keys with additional options.
+// This function allows for specifying additional options such as:
+// Latest, FilterByTS, FilterByValue, WithLabels, SelectedLabels,
+// Count, Align, Aggregator, BucketDuration, BucketTimestamp,
+// Empty, GroupByLabel and Reducer.
+// For more information - https://redis.io/commands/ts.mrange/
+func (c cmdable) TSMRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRangeOptions) *MapStringSliceInterfaceCmd {
+	args := []interface{}{"TS.MRANGE", fromTimestamp, toTimestamp}
+	if options != nil {
+		if options.Latest {
+			args = append(args, "LATEST")
+		}
+		if options.FilterByTS != nil {
+			args = append(args, "FILTER_BY_TS")
+			for _, f := range options.FilterByTS {
+				args = append(args, f)
+			}
+		}
+		if options.FilterByValue != nil {
+			args = append(args, "FILTER_BY_VALUE")
+			for _, f := range options.FilterByValue {
+				args = append(args, f)
+			}
+		}
+		if options.WithLabels {
+			args = append(args, "WITHLABELS")
+		}
+		if options.SelectedLabels != nil {
+			args = append(args, "SELECTED_LABELS")
+			args = append(args, options.SelectedLabels...)
+		}
+		if options.Count != 0 {
+			args = append(args, "COUNT", options.Count)
+		}
+		if options.Align != nil {
+			args = append(args, "ALIGN", options.Align)
+		}
+		if options.Aggregator != 0 {
+			args = append(args, "AGGREGATION", options.Aggregator.String())
+		}
+		if options.BucketDuration != 0 {
+			args = append(args, options.BucketDuration)
+		}
+		if options.BucketTimestamp != nil {
+			args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
+		}
+		if options.Empty {
+			args = append(args, "EMPTY")
+		}
+	}
+	args = append(args, "FILTER")
+	for _, f := range filterExpr {
+		args = append(args, f)
+	}
+	if options != nil {
+		if options.GroupByLabel != nil {
+			args = append(args, "GROUPBY", options.GroupByLabel)
+		}
+		if options.Reducer != nil {
+			args = append(args, "REDUCE", options.Reducer)
+		}
+	}
+	cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSMRevRange - Returns a range of samples from multiple time-series keys in reverse order.
+// For more information - https://redis.io/commands/ts.mrevrange/
+func (c cmdable) TSMRevRange(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string) *MapStringSliceInterfaceCmd {
+	args := []interface{}{"TS.MREVRANGE", fromTimestamp, toTimestamp, "FILTER"}
+	for _, f := range filterExpr {
+		args = append(args, f)
+	}
+	cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSMRevRangeWithArgs - Returns a range of samples from multiple time-series keys in reverse order with additional options.
+// This function allows for specifying additional options such as:
+// Latest, FilterByTS, FilterByValue, WithLabels, SelectedLabels,
+// Count, Align, Aggregator, BucketDuration, BucketTimestamp,
+// Empty, GroupByLabel and Reducer.
+// For more information - https://redis.io/commands/ts.mrevrange/
+func (c cmdable) TSMRevRangeWithArgs(ctx context.Context, fromTimestamp int, toTimestamp int, filterExpr []string, options *TSMRevRangeOptions) *MapStringSliceInterfaceCmd {
+	args := []interface{}{"TS.MREVRANGE", fromTimestamp, toTimestamp}
+	if options != nil {
+		if options.Latest {
+			args = append(args, "LATEST")
+		}
+		if options.FilterByTS != nil {
+			args = append(args, "FILTER_BY_TS")
+			for _, f := range options.FilterByTS {
+				args = append(args, f)
+			}
+		}
+		if options.FilterByValue != nil {
+			args = append(args, "FILTER_BY_VALUE")
+			for _, f := range options.FilterByValue {
+				args = append(args, f)
+			}
+		}
+		if options.WithLabels {
+			args = append(args, "WITHLABELS")
+		}
+		if options.SelectedLabels != nil {
+			args = append(args, "SELECTED_LABELS")
+			args = append(args, options.SelectedLabels...)
+		}
+		if options.Count != 0 {
+			args = append(args, "COUNT", options.Count)
+		}
+		if options.Align != nil {
+			args = append(args, "ALIGN", options.Align)
+		}
+		if options.Aggregator != 0 {
+			args = append(args, "AGGREGATION", options.Aggregator.String())
+		}
+		if options.BucketDuration != 0 {
+			args = append(args, options.BucketDuration)
+		}
+		if options.BucketTimestamp != nil {
+			args = append(args, "BUCKETTIMESTAMP", options.BucketTimestamp)
+		}
+		if options.Empty {
+			args = append(args, "EMPTY")
+		}
+	}
+	args = append(args, "FILTER")
+	for _, f := range filterExpr {
+		args = append(args, f)
+	}
+	if options != nil {
+		if options.GroupByLabel != nil {
+			args = append(args, "GROUPBY", options.GroupByLabel)
+		}
+		if options.Reducer != nil {
+			args = append(args, "REDUCE", options.Reducer)
+		}
+	}
+	cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSMGet - Returns the last sample of multiple time-series keys.
+// For more information - https://redis.io/commands/ts.mget/
+func (c cmdable) TSMGet(ctx context.Context, filters []string) *MapStringSliceInterfaceCmd {
+	args := []interface{}{"TS.MGET", "FILTER"}
+	for _, f := range filters {
+		args = append(args, f)
+	}
+	cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
+
+// TSMGetWithArgs - Returns the last sample of multiple time-series keys with additional options.
+// This function allows for specifying additional options such as:
+// Latest, WithLabels and SelectedLabels.
+// For more information - https://redis.io/commands/ts.mget/
+func (c cmdable) TSMGetWithArgs(ctx context.Context, filters []string, options *TSMGetOptions) *MapStringSliceInterfaceCmd {
+	args := []interface{}{"TS.MGET"}
+	if options != nil {
+		if options.Latest {
+			args = append(args, "LATEST")
+		}
+		if options.WithLabels {
+			args = append(args, "WITHLABELS")
+		}
+		if options.SelectedLabels != nil {
+			args = append(args, "SELECTED_LABELS")
+			args = append(args, options.SelectedLabels...)
+		}
+	}
+	args = append(args, "FILTER")
+	for _, f := range filters {
+		args = append(args, f)
+	}
+	cmd := NewMapStringSliceInterfaceCmd(ctx, args...)
+	_ = c(ctx, cmd)
+	return cmd
+}
diff --git a/timeseries_commands_test.go b/timeseries_commands_test.go
new file mode 100644
index 000000000..563f24e79
--- /dev/null
+++ b/timeseries_commands_test.go
@@ -0,0 +1,940 @@
+package redis_test
+
+import (
+	"context"
+	"strings"
+
+	. "github.com/bsm/ginkgo/v2"
+	. "github.com/bsm/gomega"
+
+	"github.com/redis/go-redis/v9"
+)
+
+var _ = Describe("RedisTimeseries commands", Label("timeseries"), func() {
+	ctx := context.TODO()
+	var client *redis.Client
+
+	BeforeEach(func() {
+		client = redis.NewClient(&redis.Options{Addr: rediStackAddr})
+		Expect(client.FlushDB(ctx).Err()).NotTo(HaveOccurred())
+	})
+
+	AfterEach(func() {
+		Expect(client.Close()).NotTo(HaveOccurred())
+	})
+
+	It("should TSCreate and TSCreateWithArgs", Label("timeseries", "tscreate", "tscreateWithArgs"), func() {
+		result, err := client.TSCreate(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		// Test TSCreateWithArgs
+		opt := &redis.TSOptions{Retention: 5}
+		result, err = client.TSCreateWithArgs(ctx, "2", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs"}}
+		result, err = client.TSCreateWithArgs(ctx, "3", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"Time": "Series"}, Retention: 20}
+		result, err = client.TSCreateWithArgs(ctx, "4", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		resultInfo, err := client.TSInfo(ctx, "4").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
+		// Test chunk size
+		opt = &redis.TSOptions{ChunkSize: 128}
+		result, err = client.TSCreateWithArgs(ctx, "ts-cs-1", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		resultInfo, err = client.TSInfo(ctx, "ts-cs-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
+		// Test duplicate policy
+		duplicate_policies := []string{"BLOCK", "LAST", "FIRST", "MIN", "MAX"}
+		for _, dup := range duplicate_policies {
+			keyName := "ts-dup-" + dup
+			opt = &redis.TSOptions{DuplicatePolicy: dup}
+			result, err = client.TSCreateWithArgs(ctx, keyName, opt).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(result).To(BeEquivalentTo("OK"))
+			resultInfo, err = client.TSInfo(ctx, keyName).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(strings.ToUpper(resultInfo["duplicatePolicy"].(string))).To(BeEquivalentTo(dup))
+
+		}
+	})
+	It("should TSAdd and TSAddWithArgs", Label("timeseries", "tsadd", "tsaddWithArgs"), func() {
+		result, err := client.TSAdd(ctx, "1", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		// Test TSAddWithArgs
+		opt := &redis.TSOptions{Retention: 10}
+		result, err = client.TSAddWithArgs(ctx, "2", 2, 3, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(2))
+		opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs"}}
+		result, err = client.TSAddWithArgs(ctx, "3", 3, 2, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(3))
+		opt = &redis.TSOptions{Labels: map[string]string{"Redis": "Labs", "Time": "Series"}, Retention: 10}
+		result, err = client.TSAddWithArgs(ctx, "4", 4, 2, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(4))
+		resultInfo, err := client.TSInfo(ctx, "4").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
+		// Test chunk size
+		opt = &redis.TSOptions{ChunkSize: 128}
+		result, err = client.TSAddWithArgs(ctx, "ts-cs-1", 1, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		resultInfo, err = client.TSInfo(ctx, "ts-cs-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
+		// Test duplicate policy
+		// LAST
+		opt = &redis.TSOptions{DuplicatePolicy: "LAST"}
+		result, err = client.TSAddWithArgs(ctx, "tsal-1", 1, 5, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		result, err = client.TSAddWithArgs(ctx, "tsal-1", 1, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		resultGet, err := client.TSGet(ctx, "tsal-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet.Value).To(BeEquivalentTo(10))
+		// FIRST
+		opt = &redis.TSOptions{DuplicatePolicy: "FIRST"}
+		result, err = client.TSAddWithArgs(ctx, "tsaf-1", 1, 5, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		result, err = client.TSAddWithArgs(ctx, "tsaf-1", 1, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		resultGet, err = client.TSGet(ctx, "tsaf-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet.Value).To(BeEquivalentTo(5))
+		// MAX
+		opt = &redis.TSOptions{DuplicatePolicy: "MAX"}
+		result, err = client.TSAddWithArgs(ctx, "tsam-1", 1, 5, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		result, err = client.TSAddWithArgs(ctx, "tsam-1", 1, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		resultGet, err = client.TSGet(ctx, "tsam-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet.Value).To(BeEquivalentTo(10))
+		// MIN
+		opt = &redis.TSOptions{DuplicatePolicy: "MIN"}
+		result, err = client.TSAddWithArgs(ctx, "tsami-1", 1, 5, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		result, err = client.TSAddWithArgs(ctx, "tsami-1", 1, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo(1))
+		resultGet, err = client.TSGet(ctx, "tsami-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet.Value).To(BeEquivalentTo(5))
+	})
+
+	It("should TSAlter", Label("timeseries", "tsalter"), func() {
+		result, err := client.TSCreate(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		resultInfo, err := client.TSInfo(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(0))
+
+		opt := &redis.TSAlterOptions{Retention: 10}
+		resultAlter, err := client.TSAlter(ctx, "1", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAlter).To(BeEquivalentTo("OK"))
+
+		resultInfo, err = client.TSInfo(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
+
+		resultInfo, err = client.TSInfo(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["labels"]).To(BeEquivalentTo(map[interface{}]interface{}{}))
+
+		opt = &redis.TSAlterOptions{Labels: map[string]string{"Time": "Series"}}
+		resultAlter, err = client.TSAlter(ctx, "1", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAlter).To(BeEquivalentTo("OK"))
+
+		resultInfo, err = client.TSInfo(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["labels"].(map[interface{}]interface{})["Time"]).To(BeEquivalentTo("Series"))
+		Expect(resultInfo["retentionTime"]).To(BeEquivalentTo(10))
+		Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo(redis.Nil))
+		opt = &redis.TSAlterOptions{DuplicatePolicy: "min"}
+		resultAlter, err = client.TSAlter(ctx, "1", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAlter).To(BeEquivalentTo("OK"))
+
+		resultInfo, err = client.TSInfo(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["duplicatePolicy"]).To(BeEquivalentTo("min"))
+	})
+
+	It("should TSCreateRule and TSDeleteRule", Label("timeseries", "tscreaterule", "tsdeleterule"), func() {
+		result, err := client.TSCreate(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		result, err = client.TSCreate(ctx, "2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		result, err = client.TSCreateRule(ctx, "1", "2", redis.Avg, 100).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo("OK"))
+		for i := 0; i < 50; i++ {
+			resultAdd, err := client.TSAdd(ctx, "1", 100+i*2, 1).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultAdd).To(BeEquivalentTo(100 + i*2))
+			resultAdd, err = client.TSAdd(ctx, "1", 100+i*2+1, 2).Result()
+			Expect(err).NotTo(HaveOccurred())
+			Expect(resultAdd).To(BeEquivalentTo(100 + i*2 + 1))
+
+		}
+		resultAdd, err := client.TSAdd(ctx, "1", 100*2, 1.5).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultAdd).To(BeEquivalentTo(100 * 2))
+		resultGet, err := client.TSGet(ctx, "2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet.Value).To(BeEquivalentTo(1.5))
+		Expect(resultGet.Timestamp).To(BeEquivalentTo(100))
+
+		resultDeleteRule, err := client.TSDeleteRule(ctx, "1", "2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultDeleteRule).To(BeEquivalentTo("OK"))
+		resultInfo, err := client.TSInfo(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["rules"]).To(BeEquivalentTo(map[interface{}]interface{}{}))
+	})
+
+	It("should TSIncrBy, TSIncrByWithArgs, TSDecrBy and TSDecrByWithArgs", Label("timeseries", "tsincrby", "tsdecrby", "tsincrbyWithArgs", "tsdecrbyWithArgs"), func() {
+		for i := 0; i < 100; i++ {
+			_, err := client.TSIncrBy(ctx, "1", 1).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+		result, err := client.TSGet(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result.Value).To(BeEquivalentTo(100))
+
+		for i := 0; i < 100; i++ {
+			_, err := client.TSDecrBy(ctx, "1", 1).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+		result, err = client.TSGet(ctx, "1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result.Value).To(BeEquivalentTo(0))
+
+		opt := &redis.TSIncrDecrOptions{Timestamp: 5}
+		_, err = client.TSIncrByWithArgs(ctx, "2", 1.5, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		result, err = client.TSGet(ctx, "2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result.Timestamp).To(BeEquivalentTo(5))
+		Expect(result.Value).To(BeEquivalentTo(1.5))
+
+		opt = &redis.TSIncrDecrOptions{Timestamp: 7}
+		_, err = client.TSIncrByWithArgs(ctx, "2", 2.25, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		result, err = client.TSGet(ctx, "2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result.Timestamp).To(BeEquivalentTo(7))
+		Expect(result.Value).To(BeEquivalentTo(3.75))
+
+		opt = &redis.TSIncrDecrOptions{Timestamp: 15}
+		_, err = client.TSDecrByWithArgs(ctx, "2", 1.5, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		result, err = client.TSGet(ctx, "2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result.Timestamp).To(BeEquivalentTo(15))
+		Expect(result.Value).To(BeEquivalentTo(2.25))
+
+		// Test chunk size INCRBY
+		opt = &redis.TSIncrDecrOptions{ChunkSize: 128}
+		_, err = client.TSIncrByWithArgs(ctx, "3", 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		resultInfo, err := client.TSInfo(ctx, "3").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
+
+		// Test chunk size DECRBY
+		opt = &redis.TSIncrDecrOptions{ChunkSize: 128}
+		_, err = client.TSDecrByWithArgs(ctx, "4", 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		resultInfo, err = client.TSInfo(ctx, "4").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultInfo["chunkSize"]).To(BeEquivalentTo(128))
+	})
+
+	It("should TSGet", Label("timeseries", "tsget"), func() {
+		opt := &redis.TSOptions{DuplicatePolicy: "max"}
+		resultGet, err := client.TSAddWithArgs(ctx, "foo", 2265985, 151, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet).To(BeEquivalentTo(2265985))
+		result, err := client.TSGet(ctx, "foo").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result.Timestamp).To(BeEquivalentTo(2265985))
+		Expect(result.Value).To(BeEquivalentTo(151))
+	})
+
+	It("should TSGet Latest", Label("timeseries", "tsgetlatest", "NonRedisEnterprise"), func() {
+		resultGet, err := client.TSCreate(ctx, "tsgl-1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet).To(BeEquivalentTo("OK"))
+		resultGet, err = client.TSCreate(ctx, "tsgl-2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet).To(BeEquivalentTo("OK"))
+
+		resultGet, err = client.TSCreateRule(ctx, "tsgl-1", "tsgl-2", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		Expect(resultGet).To(BeEquivalentTo("OK"))
+		_, err = client.TSAdd(ctx, "tsgl-1", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "tsgl-1", 2, 3).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "tsgl-1", 11, 7).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "tsgl-1", 13, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		result, errGet := client.TSGet(ctx, "tsgl-2").Result()
+		Expect(errGet).NotTo(HaveOccurred())
+		Expect(result.Timestamp).To(BeEquivalentTo(0))
+		Expect(result.Value).To(BeEquivalentTo(4))
+		result, errGet = client.TSGetWithArgs(ctx, "tsgl-2", &redis.TSGetOptions{Latest: true}).Result()
+		Expect(errGet).NotTo(HaveOccurred())
+		Expect(result.Timestamp).To(BeEquivalentTo(10))
+		Expect(result.Value).To(BeEquivalentTo(8))
+	})
+
+	It("should TSInfo", Label("timeseries", "tsinfo"), func() {
+		resultGet, err := client.TSAdd(ctx, "foo", 2265985, 151).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet).To(BeEquivalentTo(2265985))
+		result, err := client.TSInfo(ctx, "foo").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["firstTimestamp"]).To(BeEquivalentTo(2265985))
+	})
+
+	It("should TSMAdd", Label("timeseries", "tsmadd"), func() {
+		resultGet, err := client.TSCreate(ctx, "a").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultGet).To(BeEquivalentTo("OK"))
+		ktvSlices := make([][]interface{}, 3)
+		for i := 0; i < 3; i++ {
+			ktvSlices[i] = make([]interface{}, 3)
+			ktvSlices[i][0] = "a"
+			for j := 1; j < 3; j++ {
+				ktvSlices[i][j] = (i + j) * j
+			}
+		}
+		result, err := client.TSMAdd(ctx, ktvSlices).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]int64{1, 2, 3}))
+	})
+
+	It("should TSMGet and TSMGetWithArgs", Label("timeseries", "tsmget", "tsmgetWithArgs", "NonRedisEnterprise"), func() {
+		opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
+		resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		_, err = client.TSAdd(ctx, "a", "*", 15).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "b", "*", 25).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		result, err := client.TSMGet(ctx, []string{"Test=This"}).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][1].([]interface{})[1]).To(BeEquivalentTo(15))
+		Expect(result["b"][1].([]interface{})[1]).To(BeEquivalentTo(25))
+		mgetOpt := &redis.TSMGetOptions{WithLabels: true}
+		result, err = client.TSMGetWithArgs(ctx, []string{"Test=This"}, mgetOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "Taste": "That"}))
+
+		resultCreate, err = client.TSCreate(ctx, "c").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		resultCreateRule, err := client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreateRule).To(BeEquivalentTo("OK"))
+		_, err = client.TSAdd(ctx, "c", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 2, 3).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 11, 7).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 13, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		result, err = client.TSMGet(ctx, []string{"is_compaction=true"}).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(0), 4.0}))
+		mgetOpt = &redis.TSMGetOptions{Latest: true}
+		result, err = client.TSMGetWithArgs(ctx, []string{"is_compaction=true"}, mgetOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["d"][1]).To(BeEquivalentTo([]interface{}{int64(10), 8.0}))
+	})
+
+	It("should TSQueryIndex", Label("timeseries", "tsqueryindex"), func() {
+		opt := &redis.TSOptions{Labels: map[string]string{"Test": "This"}}
+		resultCreate, err := client.TSCreateWithArgs(ctx, "a", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		result, err := client.TSQueryIndex(ctx, []string{"Test=This"}).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		result, err = client.TSQueryIndex(ctx, []string{"Taste=That"}).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(1))
+	})
+
+	It("should TSDel and TSRange", Label("timeseries", "tsdel", "tsrange"), func() {
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+		resultDelete, err := client.TSDel(ctx, "a", 0, 21).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultDelete).To(BeEquivalentTo(22))
+
+		resultRange, err := client.TSRange(ctx, "a", 0, 21).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange).To(BeEquivalentTo([]redis.TSTimestampValue{}))
+
+		resultRange, err = client.TSRange(ctx, "a", 22, 22).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 22, Value: 1}))
+	})
+
+	It("should TSRange, TSRangeWithArgs", Label("timeseries", "tsrange", "tsrangeWithArgs", "NonRedisEnterprise"), func() {
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+
+		}
+		result, err := client.TSRange(ctx, "a", 0, 200).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(100))
+		for i := 0; i < 100; i++ {
+			client.TSAdd(ctx, "a", i+200, float64(i%7))
+		}
+		result, err = client.TSRange(ctx, "a", 0, 500).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(200))
+		fts := make([]int, 0)
+		for i := 10; i < 20; i++ {
+			fts = append(fts, i)
+		}
+		opt := &redis.TSRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
+		result, err = client.TSRangeWithArgs(ctx, "a", 0, 500, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		opt = &redis.TSRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "+"}
+		result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 10}, {Timestamp: 10, Value: 1}}))
+		opt = &redis.TSRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "5"}
+		result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 5}, {Timestamp: 5, Value: 6}}))
+		opt = &redis.TSRangeOptions{Aggregator: redis.Twa, BucketDuration: 10}
+		result, err = client.TSRangeWithArgs(ctx, "a", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 0, Value: 2.55}, {Timestamp: 10, Value: 3}}))
+		// Test Range Latest
+		resultCreate, err := client.TSCreate(ctx, "t1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		resultCreate, err = client.TSCreate(ctx, "t2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		resultRule, err := client.TSCreateRule(ctx, "t1", "t2", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRule).To(BeEquivalentTo("OK"))
+		_, errAdd := client.TSAdd(ctx, "t1", 1, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t1", 2, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t1", 11, 7).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t1", 13, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		resultRange, err := client.TSRange(ctx, "t1", 0, 20).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 1, Value: 1}))
+
+		opt = &redis.TSRangeOptions{Latest: true}
+		resultRange, err = client.TSRangeWithArgs(ctx, "t2", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
+		// Test Bucket Timestamp
+		resultCreate, err = client.TSCreate(ctx, "t3").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		_, errAdd = client.TSAdd(ctx, "t3", 15, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 17, 4).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 51, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 73, 5).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 75, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+
+		opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
+		resultRange, err = client.TSRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
+		Expect(len(resultRange)).To(BeEquivalentTo(3))
+
+		opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, BucketTimestamp: "+"}
+		resultRange, err = client.TSRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 20, Value: 4}))
+		Expect(len(resultRange)).To(BeEquivalentTo(3))
+		// Test Empty
+		_, errAdd = client.TSAdd(ctx, "t4", 15, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 17, 4).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 51, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 73, 5).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 75, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+
+		opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
+		resultRange, err = client.TSRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
+		Expect(len(resultRange)).To(BeEquivalentTo(3))
+
+		opt = &redis.TSRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, Empty: true}
+		resultRange, err = client.TSRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 4}))
+		Expect(len(resultRange)).To(BeEquivalentTo(7))
+	})
+
+	It("should TSRevRange, TSRevRangeWithArgs", Label("timeseries", "tsrevrange", "tsrevrangeWithArgs", "NonRedisEnterprise"), func() {
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+
+		}
+		result, err := client.TSRange(ctx, "a", 0, 200).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(100))
+		for i := 0; i < 100; i++ {
+			client.TSAdd(ctx, "a", i+200, float64(i%7))
+		}
+		result, err = client.TSRange(ctx, "a", 0, 500).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(200))
+
+		opt := &redis.TSRevRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
+		result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(20))
+
+		opt = &redis.TSRevRangeOptions{Count: 10}
+		result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(10))
+
+		fts := make([]int, 0)
+		for i := 10; i < 20; i++ {
+			fts = append(fts, i)
+		}
+		opt = &redis.TSRevRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
+		result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 500, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "+"}
+		result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 10, Value: 1}, {Timestamp: 0, Value: 10}}))
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "1"}
+		result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 1, Value: 10}, {Timestamp: 0, Value: 1}}))
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Twa, BucketDuration: 10}
+		result, err = client.TSRevRangeWithArgs(ctx, "a", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result).To(BeEquivalentTo([]redis.TSTimestampValue{{Timestamp: 10, Value: 3}, {Timestamp: 0, Value: 2.55}}))
+		// Test Range Latest
+		resultCreate, err := client.TSCreate(ctx, "t1").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		resultCreate, err = client.TSCreate(ctx, "t2").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		resultRule, err := client.TSCreateRule(ctx, "t1", "t2", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRule).To(BeEquivalentTo("OK"))
+		_, errAdd := client.TSAdd(ctx, "t1", 1, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t1", 2, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t1", 11, 7).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t1", 13, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		resultRange, err := client.TSRange(ctx, "t2", 0, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
+		opt = &redis.TSRevRangeOptions{Latest: true}
+		resultRange, err = client.TSRevRangeWithArgs(ctx, "t2", 0, 10, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 10, Value: 8}))
+		resultRange, err = client.TSRevRangeWithArgs(ctx, "t2", 0, 9, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 0, Value: 4}))
+		// Test Bucket Timestamp
+		resultCreate, err = client.TSCreate(ctx, "t3").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		_, errAdd = client.TSAdd(ctx, "t3", 15, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 17, 4).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 51, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 73, 5).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t3", 75, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
+		resultRange, err = client.TSRevRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
+		Expect(len(resultRange)).To(BeEquivalentTo(3))
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, BucketTimestamp: "+"}
+		resultRange, err = client.TSRevRangeWithArgs(ctx, "t3", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 80, Value: 5}))
+		Expect(len(resultRange)).To(BeEquivalentTo(3))
+		// Test Empty
+		_, errAdd = client.TSAdd(ctx, "t4", 15, 1).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 17, 4).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 51, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 73, 5).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+		_, errAdd = client.TSAdd(ctx, "t4", 75, 3).Result()
+		Expect(errAdd).NotTo(HaveOccurred())
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10}
+		resultRange, err = client.TSRevRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
+		Expect(len(resultRange)).To(BeEquivalentTo(3))
+
+		opt = &redis.TSRevRangeOptions{Aggregator: redis.Max, Align: 0, BucketDuration: 10, Empty: true}
+		resultRange, err = client.TSRevRangeWithArgs(ctx, "t4", 0, 100, opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultRange[0]).To(BeEquivalentTo(redis.TSTimestampValue{Timestamp: 70, Value: 5}))
+		Expect(len(resultRange)).To(BeEquivalentTo(7))
+	})
+
+	It("should TSMRange and TSMRangeWithArgs", Label("timeseries", "tsmrange", "tsmrangeWithArgs"), func() {
+		createOpt := &redis.TSOptions{Labels: map[string]string{"Test": "This", "team": "ny"}}
+		resultCreate, err := client.TSCreateWithArgs(ctx, "a", createOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		createOpt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That", "team": "sf"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "b", createOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+			_, err = client.TSAdd(ctx, "b", i, float64(i%11)).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+
+		result, err := client.TSMRange(ctx, 0, 200, []string{"Test=This"}).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(100))
+		// Test Count
+		mrangeOpt := &redis.TSMRangeOptions{Count: 10}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(10))
+		// Test Aggregation and BucketDuration
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i+200, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+		mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 500, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(20))
+		// Test WithLabels
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
+		mrangeOpt = &redis.TSMRangeOptions{WithLabels: true}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "team": "ny"}))
+		// Test SelectedLabels
+		mrangeOpt = &redis.TSMRangeOptions{SelectedLabels: []interface{}{"team"}}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "ny"}))
+		Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "sf"}))
+		// Test FilterBy
+		fts := make([]int, 0)
+		for i := 10; i < 20; i++ {
+			fts = append(fts, i)
+		}
+		mrangeOpt = &redis.TSMRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(15), 1.0}, []interface{}{int64(16), 2.0}}))
+		// Test GroupBy
+		mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "Test", Reducer: "sum"}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 2.0}, []interface{}{int64(2), 4.0}, []interface{}{int64(3), 6.0}}))
+
+		mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "Test", Reducer: "max"}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(3), 3.0}}))
+
+		mrangeOpt = &redis.TSMRangeOptions{GroupByLabel: "team", Reducer: "min"}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		Expect(result["team=ny"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(3), 3.0}}))
+		Expect(result["team=sf"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 0.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(3), 3.0}}))
+		// Test Align
+		mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "-"}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 10.0}, []interface{}{int64(10), 1.0}}))
+
+		mrangeOpt = &redis.TSMRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: 5}
+		result, err = client.TSMRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 5.0}, []interface{}{int64(5), 6.0}}))
+	})
+
+	It("should TSMRangeWithArgs Latest", Label("timeseries", "tsmrangeWithArgs", "tsmrangelatest", "NonRedisEnterprise"), func() {
+		resultCreate, err := client.TSCreate(ctx, "a").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt := &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+
+		resultCreate, err = client.TSCreate(ctx, "c").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+
+		resultCreateRule, err := client.TSCreateRule(ctx, "a", "b", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreateRule).To(BeEquivalentTo("OK"))
+		resultCreateRule, err = client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreateRule).To(BeEquivalentTo("OK"))
+
+		_, err = client.TSAdd(ctx, "a", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "a", 2, 3).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "a", 11, 7).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "a", 13, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		_, err = client.TSAdd(ctx, "c", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 2, 3).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 11, 7).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 13, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		mrangeOpt := &redis.TSMRangeOptions{Latest: true}
+		result, err := client.TSMRangeWithArgs(ctx, 0, 10, []string{"is_compaction=true"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["b"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 4.0}, []interface{}{int64(10), 8.0}}))
+		Expect(result["d"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(0), 4.0}, []interface{}{int64(10), 8.0}}))
+	})
+	It("should TSMRevRange and TSMRevRangeWithArgs", Label("timeseries", "tsmrevrange", "tsmrevrangeWithArgs"), func() {
+		createOpt := &redis.TSOptions{Labels: map[string]string{"Test": "This", "team": "ny"}}
+		resultCreate, err := client.TSCreateWithArgs(ctx, "a", createOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		createOpt = &redis.TSOptions{Labels: map[string]string{"Test": "This", "Taste": "That", "team": "sf"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "b", createOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+			_, err = client.TSAdd(ctx, "b", i, float64(i%11)).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+		result, err := client.TSMRevRange(ctx, 0, 200, []string{"Test=This"}).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(100))
+		// Test Count
+		mrangeOpt := &redis.TSMRevRangeOptions{Count: 10}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(10))
+		// Test Aggregation and BucketDuration
+		for i := 0; i < 100; i++ {
+			_, err := client.TSAdd(ctx, "a", i+200, float64(i%7)).Result()
+			Expect(err).NotTo(HaveOccurred())
+		}
+		mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Avg, BucketDuration: 10}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 500, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		Expect(len(result["a"][2].([]interface{}))).To(BeEquivalentTo(20))
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
+		// Test WithLabels
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{}))
+		mrangeOpt = &redis.TSMRevRangeOptions{WithLabels: true}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"Test": "This", "team": "ny"}))
+		// Test SelectedLabels
+		mrangeOpt = &redis.TSMRevRangeOptions{SelectedLabels: []interface{}{"team"}}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "ny"}))
+		Expect(result["b"][0]).To(BeEquivalentTo(map[interface{}]interface{}{"team": "sf"}))
+		// Test FilterBy
+		fts := make([]int, 0)
+		for i := 10; i < 20; i++ {
+			fts = append(fts, i)
+		}
+		mrangeOpt = &redis.TSMRevRangeOptions{FilterByTS: fts, FilterByValue: []int{1, 2}}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 200, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(16), 2.0}, []interface{}{int64(15), 1.0}}))
+		// Test GroupBy
+		mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "Test", Reducer: "sum"}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 6.0}, []interface{}{int64(2), 4.0}, []interface{}{int64(1), 2.0}, []interface{}{int64(0), 0.0}}))
+
+		mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "Test", Reducer: "max"}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["Test=This"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 3.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(0), 0.0}}))
+
+		mrangeOpt = &redis.TSMRevRangeOptions{GroupByLabel: "team", Reducer: "min"}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 3, []string{"Test=This"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(len(result)).To(BeEquivalentTo(2))
+		Expect(result["team=ny"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 3.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(0), 0.0}}))
+		Expect(result["team=sf"][3]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(3), 3.0}, []interface{}{int64(2), 2.0}, []interface{}{int64(1), 1.0}, []interface{}{int64(0), 0.0}}))
+		// Test Align
+		mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: "-"}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 1.0}, []interface{}{int64(0), 10.0}}))
+
+		mrangeOpt = &redis.TSMRevRangeOptions{Aggregator: redis.Count, BucketDuration: 10, Align: 1}
+		result, err = client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"team=ny"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["a"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(1), 10.0}, []interface{}{int64(0), 1.0}}))
+	})
+
+	It("should TSMRevRangeWithArgs Latest", Label("timeseries", "tsmrevrangeWithArgs", "tsmrevrangelatest", "NonRedisEnterprise"), func() {
+		resultCreate, err := client.TSCreate(ctx, "a").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt := &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "b", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+
+		resultCreate, err = client.TSCreate(ctx, "c").Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+		opt = &redis.TSOptions{Labels: map[string]string{"is_compaction": "true"}}
+		resultCreate, err = client.TSCreateWithArgs(ctx, "d", opt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreate).To(BeEquivalentTo("OK"))
+
+		resultCreateRule, err := client.TSCreateRule(ctx, "a", "b", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreateRule).To(BeEquivalentTo("OK"))
+		resultCreateRule, err = client.TSCreateRule(ctx, "c", "d", redis.Sum, 10).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(resultCreateRule).To(BeEquivalentTo("OK"))
+
+		_, err = client.TSAdd(ctx, "a", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "a", 2, 3).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "a", 11, 7).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "a", 13, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+
+		_, err = client.TSAdd(ctx, "c", 1, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 2, 3).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 11, 7).Result()
+		Expect(err).NotTo(HaveOccurred())
+		_, err = client.TSAdd(ctx, "c", 13, 1).Result()
+		Expect(err).NotTo(HaveOccurred())
+		mrangeOpt := &redis.TSMRevRangeOptions{Latest: true}
+		result, err := client.TSMRevRangeWithArgs(ctx, 0, 10, []string{"is_compaction=true"}, mrangeOpt).Result()
+		Expect(err).NotTo(HaveOccurred())
+		Expect(result["b"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 8.0}, []interface{}{int64(0), 4.0}}))
+		Expect(result["d"][2]).To(BeEquivalentTo([]interface{}{[]interface{}{int64(10), 8.0}, []interface{}{int64(0), 4.0}}))
+	})
+})
diff --git a/tx_test.go b/tx_test.go
index 9ed502c78..1146d46de 100644
--- a/tx_test.go
+++ b/tx_test.go
@@ -64,7 +64,7 @@ var _ = Describe("Tx", func() {
 		Expect(n).To(Equal(int64(100)))
 	})
 
-	It("should discard", func() {
+	It("should discard", Label("NonRedisEnterprise"), func() {
 		err := client.Watch(ctx, func(tx *redis.Tx) error {
 			cmds, err := tx.TxPipelined(ctx, func(pipe redis.Pipeliner) error {
 				pipe.Set(ctx, "key1", "hello1", 0)
diff --git a/universal.go b/universal.go
index 53ece1856..275bef3d6 100644
--- a/universal.go
+++ b/universal.go
@@ -48,6 +48,7 @@ type UniversalOptions struct {
 	PoolTimeout     time.Duration
 	MinIdleConns    int
 	MaxIdleConns    int
+	MaxActiveConns  int
 	ConnMaxIdleTime time.Duration
 	ConnMaxLifetime time.Duration
 
@@ -64,6 +65,9 @@ type UniversalOptions struct {
 	// Only failover clients.
 
 	MasterName string
+
+	DisableIndentity bool
+	IdentitySuffix   string
 }
 
 // Cluster returns cluster options created from the universal options.
@@ -102,10 +106,14 @@ func (o *UniversalOptions) Cluster() *ClusterOptions {
 		PoolTimeout:     o.PoolTimeout,
 		MinIdleConns:    o.MinIdleConns,
 		MaxIdleConns:    o.MaxIdleConns,
+		MaxActiveConns:  o.MaxActiveConns,
 		ConnMaxIdleTime: o.ConnMaxIdleTime,
 		ConnMaxLifetime: o.ConnMaxLifetime,
 
 		TLSConfig: o.TLSConfig,
+
+		DisableIndentity: o.DisableIndentity,
+		IdentitySuffix:   o.IdentitySuffix,
 	}
 }
 
@@ -144,10 +152,14 @@ func (o *UniversalOptions) Failover() *FailoverOptions {
 		PoolTimeout:     o.PoolTimeout,
 		MinIdleConns:    o.MinIdleConns,
 		MaxIdleConns:    o.MaxIdleConns,
+		MaxActiveConns:  o.MaxActiveConns,
 		ConnMaxIdleTime: o.ConnMaxIdleTime,
 		ConnMaxLifetime: o.ConnMaxLifetime,
 
 		TLSConfig: o.TLSConfig,
+
+		DisableIndentity: o.DisableIndentity,
+		IdentitySuffix:   o.IdentitySuffix,
 	}
 }
 
@@ -183,10 +195,14 @@ func (o *UniversalOptions) Simple() *Options {
 		PoolTimeout:     o.PoolTimeout,
 		MinIdleConns:    o.MinIdleConns,
 		MaxIdleConns:    o.MaxIdleConns,
+		MaxActiveConns:  o.MaxActiveConns,
 		ConnMaxIdleTime: o.ConnMaxIdleTime,
 		ConnMaxLifetime: o.ConnMaxLifetime,
 
 		TLSConfig: o.TLSConfig,
+
+		DisableIndentity: o.DisableIndentity,
+		IdentitySuffix:   o.IdentitySuffix,
 	}
 }
 
diff --git a/universal_test.go b/universal_test.go
index c8b5c7b92..747c68acb 100644
--- a/universal_test.go
+++ b/universal_test.go
@@ -17,6 +17,7 @@ var _ = Describe("UniversalClient", func() {
 	})
 
 	It("should connect to failover servers", func() {
+		Skip("Flaky Test")
 		client = redis.NewUniversalClient(&redis.UniversalOptions{
 			MasterName: sentinelName,
 			Addrs:      sentinelAddrs,
@@ -31,7 +32,7 @@ var _ = Describe("UniversalClient", func() {
 		Expect(client.Ping(ctx).Err()).NotTo(HaveOccurred())
 	})
 
-	It("should connect to clusters", func() {
+	It("should connect to clusters", Label("NonRedisEnterprise"), func() {
 		client = redis.NewUniversalClient(&redis.UniversalOptions{
 			Addrs: cluster.addrs(),
 		})
diff --git a/version.go b/version.go
index e81eb1ab9..2ea7df99a 100644
--- a/version.go
+++ b/version.go
@@ -2,5 +2,5 @@ package redis
 
 // Version is the current release version.
 func Version() string {
-	return "9.0.5"
+	return "9.5.3"
 }