diff --git a/CHANGELOG.md b/CHANGELOG.md index 82446e40..7c039d93 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,11 @@ +## [5.2.3](https://github.com/luin/ioredis/compare/v5.2.2...v5.2.3) (2022-08-23) + + +### Bug Fixes + +* type of zscore result should be nullable ([#1639](https://github.com/luin/ioredis/issues/1639)) ([a3838ae](https://github.com/luin/ioredis/commit/a3838ae7598c7d9d3aff688923403f6176d7a393)) +* update to latest profile for Redis Cloud ([#1637](https://github.com/luin/ioredis/issues/1637)) ([dccb820](https://github.com/luin/ioredis/commit/dccb8205488d63653e1d157c6e87e28bfcddd3e1)) + ## [5.2.2](https://github.com/luin/ioredis/compare/v5.2.1...v5.2.2) (2022-07-23) diff --git a/docs/classes/Cluster.html b/docs/classes/Cluster.html index fa50c16f..dc6a29b6 100644 --- a/docs/classes/Cluster.html +++ b/docs/classes/Cluster.html @@ -1,2471 +1,2471 @@ Cluster | ioredis
Options
All
  • Public
  • Public/Protected
  • All
Menu

Class Cluster

Client for the official Redis Cluster

-

Hierarchy

  • Commander
  • EventEmitter
  • Transaction
    • Cluster

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Hierarchy

  • Commander
  • EventEmitter
  • Transaction
    • Cluster

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Properties

options

options: ClusterOptions

slots

slots: string[][] = []

status

status: ClusterStatus

Accessors

autoPipelineQueueSize

  • get autoPipelineQueueSize(): number

Properties

options

options: ClusterOptions

slots

slots: string[][] = []

status

status: ClusterStatus

Accessors

autoPipelineQueueSize

  • get autoPipelineQueueSize(): number

  • Get the number of commands queued in automatic pipelines.

    This is not available (and returns 0) until the cluster is connected and slots information have been received.

    -

    Returns number

Methods

acl

  • acl(subcommand: "CAT", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "CAT", categoryname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
  • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]): Promise<number>
  • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]): Promise<number>
  • acl(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<string>): Promise<string>
  • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
  • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<string>
  • acl(subcommand: "GENPASS", callback?: Callback<string>): Promise<string>
  • acl(subcommand: "GENPASS", bits: string | number, callback?: Callback<string>): Promise<string>
  • acl(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<string[]>): Promise<string[]>
  • acl(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "LIST", callback?: Callback<string[]>): Promise<string[]>
  • acl(subcommand: "LOAD", callback?: Callback<"OK">): Promise<"OK">
  • acl(subcommand: "LOG", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "LOG", count: string | number, callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "LOG", reset: "RESET", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "SAVE", callback?: Callback<"OK">): Promise<"OK">
  • acl(subcommand: "SETUSER", username: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
  • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]): Promise<"OK">
  • acl(subcommand: "USERS", callback?: Callback<string[]>): Promise<string[]>
  • acl(subcommand: "WHOAMI", callback?: Callback<string>): Promise<string>

Methods

acl

  • acl(subcommand: "CAT", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "CAT", categoryname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
  • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]): Promise<number>
  • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]): Promise<number>
  • acl(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<string>): Promise<string>
  • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
  • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<string>
  • acl(subcommand: "GENPASS", callback?: Callback<string>): Promise<string>
  • acl(subcommand: "GENPASS", bits: string | number, callback?: Callback<string>): Promise<string>
  • acl(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<string[]>): Promise<string[]>
  • acl(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "LIST", callback?: Callback<string[]>): Promise<string[]>
  • acl(subcommand: "LOAD", callback?: Callback<"OK">): Promise<"OK">
  • acl(subcommand: "LOG", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "LOG", count: string | number, callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "LOG", reset: "RESET", callback?: Callback<unknown>): Promise<unknown>
  • acl(subcommand: "SAVE", callback?: Callback<"OK">): Promise<"OK">
  • acl(subcommand: "SETUSER", username: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
  • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]): Promise<"OK">
  • acl(subcommand: "USERS", callback?: Callback<string[]>): Promise<string[]>
  • acl(subcommand: "WHOAMI", callback?: Callback<string>): Promise<string>

  • List the ACL categories or the commands inside a category

    • group: server
    • complexity: O(1) since the categories and commands are a fixed set.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "CAT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CAT"
    • categoryname: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "CAT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CAT"
    • categoryname: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Remove the specified ACL users and the associated rules

    • group: server
    • complexity: O(1) amortized time considering the typical user.
    • since: 6.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]

    Returns Promise<number>

  • +

    Parameters

    • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]

    Returns Promise<number>

  • Returns whether the user can execute the given command without executing the command.

    • group: server
    • complexity: O(1).
    • since: 7.0.0
    -

    Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<string>

  • Generate a pseudorandom secure password to use for ACL users

    • group: server
    • complexity: O(1)
    • since: 6.0.0
    -

    Parameters

    • subcommand: "GENPASS"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "GENPASS"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Get the rules for a specific ACL user

    • group: server
    • complexity: O(N). Where N is the number of password, command and pattern rules that the user has.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • +

    Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 6.0.0
    -

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • List the current ACL rules in ACL config file format

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • +

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • Reload the ACLs from the configured ACL file

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "LOAD"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "LOAD"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • List latest events denied because of ACLs in place

    • group: server
    • complexity: O(N) with N being the number of entries shown.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "LOG"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LOG"
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LOG"
    • reset: "RESET"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "LOG"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LOG"
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LOG"
    • reset: "RESET"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Save the current ACL rules in the configured ACL file

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "SAVE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "SAVE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Modify or create the rules for a specific ACL user

    • group: server
    • complexity: O(N). Where N is the number of rules provided.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "SETUSER"
    • username: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "SETUSER"
    • username: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]

    Returns Promise<"OK">

  • List the username of all the configured ACL rules

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0
    -

    Parameters

    • subcommand: "USERS"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • +

    Parameters

    • subcommand: "USERS"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • Return the name of the user associated to the current connection

    • group: server
    • complexity: O(1)
    • since: 6.0.0
    -

    Parameters

    • subcommand: "WHOAMI"
    • Optional callback: Callback<string>

    Returns Promise<string>

aclBuffer

  • aclBuffer(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
  • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
  • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<Buffer>
  • aclBuffer(subcommand: "GENPASS", callback?: Callback<Buffer>): Promise<Buffer>
  • aclBuffer(subcommand: "GENPASS", bits: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • aclBuffer(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
  • aclBuffer(subcommand: "LIST", callback?: Callback<Buffer[]>): Promise<Buffer[]>
  • aclBuffer(subcommand: "USERS", callback?: Callback<Buffer[]>): Promise<Buffer[]>
  • aclBuffer(subcommand: "WHOAMI", callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GENPASS"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "USERS"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "WHOAMI"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

addBuiltinCommand

  • addBuiltinCommand(commandName: string): void
  • +

    Parameters

    • subcommand: "WHOAMI"
    • Optional callback: Callback<string>

    Returns Promise<string>

aclBuffer

  • aclBuffer(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
  • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
  • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<Buffer>
  • aclBuffer(subcommand: "GENPASS", callback?: Callback<Buffer>): Promise<Buffer>
  • aclBuffer(subcommand: "GENPASS", bits: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • aclBuffer(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
  • aclBuffer(subcommand: "LIST", callback?: Callback<Buffer[]>): Promise<Buffer[]>
  • aclBuffer(subcommand: "USERS", callback?: Callback<Buffer[]>): Promise<Buffer[]>
  • aclBuffer(subcommand: "WHOAMI", callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GENPASS"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "USERS"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "WHOAMI"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

addBuiltinCommand

  • addBuiltinCommand(commandName: string): void

  • Create add builtin command

    -

    Parameters

    • commandName: string

    Returns void

append

  • append(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

append

  • append(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

  • Append a value to a key

    • group: string
    • complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.
    • since: 2.0.0
    -

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

asking

  • asking(callback?: Callback<"OK">): Promise<"OK">
  • +

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

asking

  • asking(callback?: Callback<"OK">): Promise<"OK">

  • Sent by cluster clients after an -ASK redirect

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

auth

  • auth(password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • auth(username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">

auth

  • auth(password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • auth(username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">

  • Authenticate to the server

    • group: connection
    • complexity: O(N) where N is the number of passwords defined for the user
    • since: 1.0.0
    -

    Parameters

    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

bgrewriteaof

  • bgrewriteaof(callback?: Callback<string>): Promise<string>
  • +

    Parameters

    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

bgrewriteaof

  • bgrewriteaof(callback?: Callback<string>): Promise<string>

  • Asynchronously rewrite the append-only file

    • group: server
    • complexity: O(1)
    • since: 1.0.0
    -

    Parameters

    • Optional callback: Callback<string>

    Returns Promise<string>

bgrewriteaofBuffer

  • bgrewriteaofBuffer(callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

bgsave

  • bgsave(callback?: Callback<"OK">): Promise<"OK">
  • bgsave(schedule: "SCHEDULE", callback?: Callback<"OK">): Promise<"OK">
  • +

    Parameters

    • Optional callback: Callback<string>

    Returns Promise<string>

bgrewriteaofBuffer

  • bgrewriteaofBuffer(callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

bgsave

  • bgsave(callback?: Callback<"OK">): Promise<"OK">
  • bgsave(schedule: "SCHEDULE", callback?: Callback<"OK">): Promise<"OK">

  • Asynchronously save the dataset to disk

    • group: server
    • complexity: O(1)
    • since: 1.0.0
    -

    Parameters

    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • schedule: "SCHEDULE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

bitcount

  • bitcount(key: RedisKey, callback?: Callback<number>): Promise<number>
  • bitcount(key: RedisKey, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
  • bitcount(key: RedisKey, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
  • bitcount(key: RedisKey, start: string | number, end: string | number, bit: "BIT", callback?: Callback<number>): Promise<number>
  • +

    Parameters

    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • schedule: "SCHEDULE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

bitcount

  • bitcount(key: RedisKey, callback?: Callback<number>): Promise<number>
  • bitcount(key: RedisKey, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
  • bitcount(key: RedisKey, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
  • bitcount(key: RedisKey, start: string | number, end: string | number, bit: "BIT", callback?: Callback<number>): Promise<number>

  • Count set bits in a string

    • group: bitmap
    • complexity: O(N)
    • since: 2.6.0
    -

    Parameters

    • key: RedisKey
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • byte: "BYTE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • bit: "BIT"
    • Optional callback: Callback<number>

    Returns Promise<number>

bitfield

  • bitfield(key: RedisKey, encodingOffsetToken: "GET", encoding: string | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • +

    Parameters

    • key: RedisKey
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • byte: "BYTE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • bit: "BIT"
    • Optional callback: Callback<number>

    Returns Promise<number>

bitfield

  • bitfield(key: RedisKey, encodingOffsetToken: "GET", encoding: string | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
  • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>

  • Perform arbitrary bitfield integer operations on strings

    • group: bitmap
    • complexity: O(1) for each subcommand specified
    • since: 3.2.0
    -

    Parameters

    • key: RedisKey
    • encodingOffsetToken: "GET"
    • encoding: string | Buffer
    • offset: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

bitfield_ro

  • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
  • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]): Promise<unknown[]>
  • +

    Parameters

    • key: RedisKey
    • encodingOffsetToken: "GET"
    • encoding: string | Buffer
    • offset: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

bitfield_ro

  • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
  • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]): Promise<unknown[]>

  • Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD

    • group: bitmap
    • complexity: O(1) for each subcommand specified
    • since: 6.0.0
    -

    Parameters

    • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]

    Returns Promise<unknown[]>

bitop

  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]): Promise<number>
  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[]]): Promise<number>
  • +

    Parameters

    • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]

    Returns Promise<unknown[]>

bitop

  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]): Promise<number>
  • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[]]): Promise<number>

  • Perform bitwise operations between strings

    • group: bitmap
    • complexity: O(N)
    • since: 2.6.0
    -

    Parameters

    • Rest ...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest ...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest ...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

bitpos

  • bitpos(key: RedisKey, bit: string | number, callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, bit1: "BIT", callback?: Callback<number>): Promise<number>

bitpos

  • bitpos(key: RedisKey, bit: string | number, callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
  • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, bit1: "BIT", callback?: Callback<number>): Promise<number>

  • Find first bit set or clear in a string

    • group: bitmap
    • complexity: O(N)
    • since: 2.8.7
    -

    Parameters

    • key: RedisKey
    • bit: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • byte: "BYTE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • bit1: "BIT"
    • Optional callback: Callback<number>

    Returns Promise<number>

blmove

  • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • +

    Parameters

    • key: RedisKey
    • bit: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • byte: "BYTE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • bit1: "BIT"
    • Optional callback: Callback<number>

    Returns Promise<number>

blmove

  • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
  • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>

  • Pop an element from a list, push it to another list and return it; or block until one is available

    • group: list
    • complexity: O(1)
    • since: 6.2.0
    -

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

blmoveBuffer

  • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

blmpop

  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • +

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

blmoveBuffer

  • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
  • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

blmpop

  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
  • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>

  • Pop elements from a list, or block until one is available

    • group: list
    • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
    • since: 7.0.0
    -

    Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

blmpopBuffer

  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

blpop

  • blpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • blpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • blpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
  • blpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
  • +

    Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: string, members: string[]]>

blmpopBuffer

  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
  • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<[key: Buffer, members: Buffer[]]>

blpop

  • blpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • blpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • blpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
  • blpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>

  • Remove and get the first element in a list, or block until one is available

    • group: list
    • complexity: O(N) where N is the number of provided keys.
    • since: 2.0.0
    -

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

blpopBuffer

  • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
  • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

brpop

  • brpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • brpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • brpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
  • brpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
  • +

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

blpopBuffer

  • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
  • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

brpop

  • brpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • brpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
  • brpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
  • brpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>

  • Remove and get the last element in a list, or block until one is available

    • group: list
    • complexity: O(N) where N is the number of provided keys.
    • since: 2.0.0
    -

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

brpopBuffer

  • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
  • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

brpoplpush

  • brpoplpush(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<string>): Promise<string>
  • +

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[string, string]>

brpopBuffer

  • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
  • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
  • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[Buffer, Buffer]>

brpoplpush

  • brpoplpush(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<string>): Promise<string>

  • Pop an element from a list, push it to another list and return it; or block until one is available

    • group: list
    • complexity: O(1)
    • since: 2.2.0
    -

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • timeout: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

brpoplpushBuffer

  • brpoplpushBuffer(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

bzmpop

  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>

brpoplpushBuffer

  • brpoplpushBuffer(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

bzmpop

  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
  • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>

  • Remove and return members with scores in a sorted set or block until one is available

    • group: sorted-set
    • complexity: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 7.0.0
    -

    Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

bzpopmax

  • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmax(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
  • bzpopmax(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
  • +

    Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

bzpopmax

  • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmax(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
  • bzpopmax(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>

  • Remove and return the member with the highest score from one or more sorted sets, or block until one is available

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 5.0.0
    -

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

bzpopmaxBuffer

  • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

bzpopmin

  • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmin(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
  • bzpopmin(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
  • +

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

bzpopmaxBuffer

  • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

bzpopmin

  • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmin(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
  • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
  • bzpopmin(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>

  • Remove and return the member with the lowest score from one or more sorted sets, or block until one is available

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 5.0.0
    -

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

bzpopminBuffer

  • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

call

  • call(command: string, callback?: Callback<unknown>): Promise<unknown>
  • call(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
  • call(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • call(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>
  • +

    Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: string, member: string, score: string]>

bzpopminBuffer

  • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
  • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

call

  • call(command: string, callback?: Callback<unknown>): Promise<unknown>
  • call(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
  • call(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • call(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

  • Call arbitrary commands.

    redis.call('set', 'foo', 'bar') is the same as redis.set('foo', 'bar'), so the only case you need to use this method is when the command is not supported by ioredis.

    redis.call('set', 'foo', 'bar');
    redis.call('get', 'foo', (err, value) => {
      // value === 'bar'
    });
    -

    Parameters

    • command: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

callBuffer

  • callBuffer(command: string, callback?: Callback<unknown>): Promise<unknown>
  • callBuffer(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
  • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

  • Parameters

    • command: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

client

  • client(subcommand: "CACHING", yes: "YES", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "CACHING", no: "NO", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "GETNAME", callback?: Callback<string>): Promise<string>
  • client(subcommand: "GETREDIR", callback?: Callback<number>): Promise<number>
  • client(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "ID", callback?: Callback<number>): Promise<number>
  • client(subcommand: "INFO", callback?: Callback<string>): Promise<string>
  • client(...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "KILL", ...args: RedisValue[]]): Promise<unknown>
  • client(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", normal: "NORMAL", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", master: "MASTER", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", replica: "REPLICA", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "NO-EVICT", on: "ON", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "NO-EVICT", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "PAUSE", timeout: string | number, callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "PAUSE", timeout: string | number, write: "WRITE", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "PAUSE", timeout: string | number, all: "ALL", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "REPLY", on: "ON", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "REPLY", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "REPLY", skip: "SKIP", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "SETNAME", connectionName: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • client(...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "TRACKING", ...args: RedisValue[]]): Promise<unknown>
  • client(subcommand: "TRACKINGINFO", callback?: Callback<string>): Promise<string>
  • client(subcommand: "UNBLOCK", clientId: string | number, callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "UNBLOCK", clientId: string | number, timeout: "TIMEOUT", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "UNBLOCK", clientId: string | number, error: "ERROR", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "UNPAUSE", callback?: Callback<"OK">): Promise<"OK">
  • +

    Parameters

    • command: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

callBuffer

  • callBuffer(command: string, callback?: Callback<unknown>): Promise<unknown>
  • callBuffer(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
  • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

  • Parameters

    • command: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

client

  • client(subcommand: "CACHING", yes: "YES", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "CACHING", no: "NO", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "GETNAME", callback?: Callback<string>): Promise<string>
  • client(subcommand: "GETREDIR", callback?: Callback<number>): Promise<number>
  • client(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "ID", callback?: Callback<number>): Promise<number>
  • client(subcommand: "INFO", callback?: Callback<string>): Promise<string>
  • client(...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "KILL", ...args: RedisValue[]]): Promise<unknown>
  • client(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", normal: "NORMAL", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", master: "MASTER", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", replica: "REPLICA", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", callback?: Callback<unknown>): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
  • client(subcommand: "NO-EVICT", on: "ON", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "NO-EVICT", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "PAUSE", timeout: string | number, callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "PAUSE", timeout: string | number, write: "WRITE", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "PAUSE", timeout: string | number, all: "ALL", callback?: Callback<"OK">): Promise<"OK">
  • client(subcommand: "REPLY", on: "ON", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "REPLY", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "REPLY", skip: "SKIP", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "SETNAME", connectionName: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • client(...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
  • client(...args: [subcommand: "TRACKING", ...args: RedisValue[]]): Promise<unknown>
  • client(subcommand: "TRACKINGINFO", callback?: Callback<string>): Promise<string>
  • client(subcommand: "UNBLOCK", clientId: string | number, callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "UNBLOCK", clientId: string | number, timeout: "TIMEOUT", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "UNBLOCK", clientId: string | number, error: "ERROR", callback?: Callback<unknown>): Promise<unknown>
  • client(subcommand: "UNPAUSE", callback?: Callback<"OK">): Promise<"OK">

  • Instruct the server about tracking or not keys in the next request

    • group: connection
    • complexity: O(1)
    • since: 6.0.0
    -

    Parameters

    • subcommand: "CACHING"
    • yes: "YES"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "CACHING"
    • no: "NO"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "CACHING"
    • yes: "YES"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "CACHING"
    • no: "NO"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Get the current connection name

    • group: connection
    • complexity: O(1)
    • since: 2.6.9
    -

    Parameters

    • subcommand: "GETNAME"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "GETNAME"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Get tracking notifications redirection client ID if any

    • group: connection
    • complexity: O(1)
    • since: 6.0.0
    -

    Parameters

    • subcommand: "GETREDIR"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • +

    Parameters

    • subcommand: "GETREDIR"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Show helpful text about the different subcommands

    • group: connection
    • complexity: O(1)
    • since: 5.0.0
    -

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Returns the client ID for the current connection

    • group: connection
    • complexity: O(1)
    • since: 5.0.0
    -

    Parameters

    • subcommand: "ID"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • +

    Parameters

    • subcommand: "ID"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Returns information about the current client connection.

    • group: connection
    • complexity: O(1)
    • since: 6.2.0
    -

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Kill the connection of a client

    • group: connection
    • complexity: O(N) where N is the number of client connections
    • since: 2.4.0
    -

    Parameters

    • Rest ...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "KILL", ...args: RedisValue[]]

    Returns Promise<unknown>

  • +

    Parameters

    • Rest ...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "KILL", ...args: RedisValue[]]

    Returns Promise<unknown>

  • Get the list of client connections

    • group: connection
    • complexity: O(N) where N is the number of client connections
    • since: 2.4.0
    -

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • normal: "NORMAL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • master: "MASTER"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • replica: "REPLICA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • pubsub: "PUBSUB"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • normal: "NORMAL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • master: "MASTER"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • replica: "REPLICA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • pubsub: "PUBSUB"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Set client eviction mode for the current connection

    • group: connection
    • complexity: O(1)
    • since: 7.0.0
    -

    Parameters

    • subcommand: "NO-EVICT"
    • on: "ON"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "NO-EVICT"
    • off: "OFF"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "NO-EVICT"
    • on: "ON"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "NO-EVICT"
    • off: "OFF"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Stop processing commands from clients for some time

    • group: connection
    • complexity: O(1)
    • since: 2.9.50
    -

    Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • write: "WRITE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • all: "ALL"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • write: "WRITE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • all: "ALL"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Instruct the server whether to reply to commands

    • group: connection
    • complexity: O(1)
    • since: 3.2.0
    -

    Parameters

    • subcommand: "REPLY"
    • on: "ON"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "REPLY"
    • off: "OFF"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "REPLY"
    • skip: "SKIP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "REPLY"
    • on: "ON"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "REPLY"
    • off: "OFF"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "REPLY"
    • skip: "SKIP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Set the current connection name

    • group: connection
    • complexity: O(1)
    • since: 2.6.9
    -

    Parameters

    • subcommand: "SETNAME"
    • connectionName: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "SETNAME"
    • connectionName: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Enable or disable server assisted client side caching support

    • group: connection
    • complexity: O(1). Some options may introduce additional complexity.
    • since: 6.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[]]

    Returns Promise<unknown>

  • +

    Parameters

    • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[]]

    Returns Promise<unknown>

  • Return information about server assisted client side caching for the current connection

    • group: connection
    • complexity: O(1)
    • since: 6.2.0
    -

    Parameters

    • subcommand: "TRACKINGINFO"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "TRACKINGINFO"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Unblock a client blocked in a blocking command from a different connection

    • group: connection
    • complexity: O(log N) where N is the number of client connections
    • since: 5.0.0
    -

    Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • timeout: "TIMEOUT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • error: "ERROR"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • timeout: "TIMEOUT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • error: "ERROR"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Resume processing of clients that were paused

    • group: connection
    • complexity: O(N) Where N is the number of paused clients
    • since: 6.2.0
    -

    Parameters

    • subcommand: "UNPAUSE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

clientBuffer

  • clientBuffer(subcommand: "GETNAME", callback?: Callback<Buffer>): Promise<Buffer>
  • clientBuffer(subcommand: "INFO", callback?: Callback<Buffer>): Promise<Buffer>
  • clientBuffer(subcommand: "TRACKINGINFO", callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • subcommand: "GETNAME"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "TRACKINGINFO"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

cluster

  • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(subcommand: "BUMPEPOCH", callback?: Callback<"BUMPED" | "STILL">): Promise<"BUMPED" | "STILL">
  • cluster(subcommand: "COUNT-FAILURE-REPORTS", nodeId: string | number | Buffer, callback?: Callback<number>): Promise<number>
  • cluster(subcommand: "COUNTKEYSINSLOT", slot: string | number, callback?: Callback<number>): Promise<number>
  • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(subcommand: "FAILOVER", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "FAILOVER", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "FAILOVER", takeover: "TAKEOVER", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "FLUSHSLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(subcommand: "FORGET", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "GETKEYSINSLOT", slot: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
  • cluster(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "INFO", callback?: Callback<string>): Promise<string>
  • cluster(subcommand: "KEYSLOT", key: string | Buffer, callback?: Callback<number>): Promise<number>
  • cluster(subcommand: "LINKS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • cluster(subcommand: "MEET", ip: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "MYID", callback?: Callback<string>): Promise<string>
  • cluster(subcommand: "NODES", callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "REPLICAS", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "REPLICATE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "RESET", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "RESET", hard: "HARD", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "RESET", soft: "SOFT", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SAVECONFIG", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SET-CONFIG-EPOCH", configEpoch: string | number, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "IMPORTING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "MIGRATING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "NODE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, stable: "STABLE", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SHARDS", callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "SLAVES", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "SLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • +

    Parameters

    • subcommand: "UNPAUSE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

clientBuffer

  • clientBuffer(subcommand: "GETNAME", callback?: Callback<Buffer>): Promise<Buffer>
  • clientBuffer(subcommand: "INFO", callback?: Callback<Buffer>): Promise<Buffer>
  • clientBuffer(subcommand: "TRACKINGINFO", callback?: Callback<Buffer>): Promise<Buffer>

  • Parameters

    • subcommand: "GETNAME"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "TRACKINGINFO"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

cluster

  • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(subcommand: "BUMPEPOCH", callback?: Callback<"BUMPED" | "STILL">): Promise<"BUMPED" | "STILL">
  • cluster(subcommand: "COUNT-FAILURE-REPORTS", nodeId: string | number | Buffer, callback?: Callback<number>): Promise<number>
  • cluster(subcommand: "COUNTKEYSINSLOT", slot: string | number, callback?: Callback<number>): Promise<number>
  • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(subcommand: "FAILOVER", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "FAILOVER", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "FAILOVER", takeover: "TAKEOVER", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "FLUSHSLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
  • cluster(subcommand: "FORGET", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "GETKEYSINSLOT", slot: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
  • cluster(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "INFO", callback?: Callback<string>): Promise<string>
  • cluster(subcommand: "KEYSLOT", key: string | Buffer, callback?: Callback<number>): Promise<number>
  • cluster(subcommand: "LINKS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • cluster(subcommand: "MEET", ip: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "MYID", callback?: Callback<string>): Promise<string>
  • cluster(subcommand: "NODES", callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "REPLICAS", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "REPLICATE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "RESET", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "RESET", hard: "HARD", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "RESET", soft: "SOFT", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SAVECONFIG", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SET-CONFIG-EPOCH", configEpoch: string | number, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "IMPORTING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "MIGRATING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "NODE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SETSLOT", slot: string | number, stable: "STABLE", callback?: Callback<"OK">): Promise<"OK">
  • cluster(subcommand: "SHARDS", callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "SLAVES", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
  • cluster(subcommand: "SLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Assign new hash slots to receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of hash slot arguments
    • since: 3.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • +

    Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Assign new hash slots to receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
    • since: 7.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • +

    Parameters

    • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Advance the cluster config epoch

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "BUMPEPOCH"
    • Optional callback: Callback<"BUMPED" | "STILL">

    Returns Promise<"BUMPED" | "STILL">

  • +

    Parameters

    • subcommand: "BUMPEPOCH"
    • Optional callback: Callback<"BUMPED" | "STILL">

    Returns Promise<"BUMPED" | "STILL">

  • Return the number of failure reports active for a given node

    • group: cluster
    • complexity: O(N) where N is the number of failure reports
    • since: 3.0.0
    -

    Parameters

    • subcommand: "COUNT-FAILURE-REPORTS"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • +

    Parameters

    • subcommand: "COUNT-FAILURE-REPORTS"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Return the number of local keys in the specified hash slot

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "COUNTKEYSINSLOT"
    • slot: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • +

    Parameters

    • subcommand: "COUNTKEYSINSLOT"
    • slot: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Set hash slots as unbound in receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of hash slot arguments
    • since: 3.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • +

    Parameters

    • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Set hash slots as unbound in receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
    • since: 7.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • +

    Parameters

    • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Forces a replica to perform a manual failover of its master.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "FAILOVER"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "FAILOVER"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "FAILOVER"
    • takeover: "TAKEOVER"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "FAILOVER"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "FAILOVER"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "FAILOVER"
    • takeover: "TAKEOVER"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Delete a node's own slots information

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "FLUSHSLOTS"
    • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • +

    Parameters

    • subcommand: "FLUSHSLOTS"
    • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Remove a node from the nodes table

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "FORGET"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "FORGET"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Return local key names in the specified hash slot

    • group: cluster
    • complexity: O(log(N)) where N is the number of requested keys
    • since: 3.0.0
    -

    Parameters

    • subcommand: "GETKEYSINSLOT"
    • slot: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • +

    Parameters

    • subcommand: "GETKEYSINSLOT"
    • slot: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • Show helpful text about the different subcommands

    • group: cluster
    • complexity: O(1)
    • since: 5.0.0
    -

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Provides info about Redis Cluster node state

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Returns the hash slot of the specified key

    • group: cluster
    • complexity: O(N) where N is the number of bytes in the key
    • since: 3.0.0
    -

    Parameters

    • subcommand: "KEYSLOT"
    • key: string | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • +

    Parameters

    • subcommand: "KEYSLOT"
    • key: string | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Returns a list of all TCP links to and from peer nodes in cluster

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 7.0.0
    -

    Parameters

    • subcommand: "LINKS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "LINKS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Force a node cluster to handshake with another node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "MEET"
    • ip: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "MEET"
    • ip: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Return the node id

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "MYID"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • +

    Parameters

    • subcommand: "MYID"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • Get Cluster config for the node

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 3.0.0
    -

    Parameters

    • subcommand: "NODES"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "NODES"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • List replica nodes of the specified master node

    • group: cluster
    • complexity: O(1)
    • since: 5.0.0
    -

    Parameters

    • subcommand: "REPLICAS"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "REPLICAS"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Reconfigure a node as a replica of the specified master node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "REPLICATE"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "REPLICATE"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Reset a Redis Cluster node

    • group: cluster
    • complexity: O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.
    • since: 3.0.0
    -

    Parameters

    • subcommand: "RESET"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "RESET"
    • hard: "HARD"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "RESET"
    • soft: "SOFT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "RESET"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "RESET"
    • hard: "HARD"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "RESET"
    • soft: "SOFT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Forces the node to save cluster state on disk

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "SAVECONFIG"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "SAVECONFIG"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Set the configuration epoch in a new node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "SET-CONFIG-EPOCH"
    • configEpoch: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "SET-CONFIG-EPOCH"
    • configEpoch: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Bind a hash slot to a specific node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "IMPORTING"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "MIGRATING"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "NODE"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • stable: "STABLE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • +

    Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "IMPORTING"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "MIGRATING"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "NODE"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • stable: "STABLE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • Get array of cluster slots to node mappings

    • group: cluster
    • complexity: O(N) where N is the total number of cluster nodes
    • since: 7.0.0
    -

    Parameters

    • subcommand: "SHARDS"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "SHARDS"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • List replica nodes of the specified master node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0
    -

    Parameters

    • subcommand: "SLAVES"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "SLAVES"
    • nodeId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Get array of Cluster slot to node mappings

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 3.0.0
    -

    Parameters

    • subcommand: "SLOTS"
    • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

command

  • command(subcommand: "COUNT", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "DOCS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
  • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
  • command(subcommand: "GETKEYS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "GETKEYSANDFLAGS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "INFO", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
  • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
  • command(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "LIST", filterby: "FILTERBY", moduleNameToken: "MODULE", moduleName: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "LIST", filterby: "FILTERBY", categoryToken: "ACLCAT", category: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "LIST", filterby: "FILTERBY", patternToken: "PATTERN", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
  • +

    Parameters

    • subcommand: "SLOTS"
    • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

command

  • command(subcommand: "COUNT", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "DOCS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
  • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
  • command(subcommand: "GETKEYS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "GETKEYSANDFLAGS", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "INFO", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
  • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
  • command(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "LIST", filterby: "FILTERBY", moduleNameToken: "MODULE", moduleName: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "LIST", filterby: "FILTERBY", categoryToken: "ACLCAT", category: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
  • command(subcommand: "LIST", filterby: "FILTERBY", patternToken: "PATTERN", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>

  • Get total number of Redis commands

    • group: server
    • complexity: O(1)
    • since: 2.8.13
    -

    Parameters

    • subcommand: "COUNT"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "COUNT"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get array of specific Redis command documentation

    • group: server
    • complexity: O(N) where N is the number of commands to look up
    • since: 7.0.0
    -

    Parameters

    • subcommand: "DOCS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "DOCS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • Extract keys given a full Redis command

    • group: server
    • complexity: O(N) where N is the number of arguments to the command
    • since: 2.8.13
    -

    Parameters

    • subcommand: "GETKEYS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "GETKEYS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Extract keys and access flags given a full Redis command

    • group: server
    • complexity: O(N) where N is the number of arguments to the command
    • since: 7.0.0
    -

    Parameters

    • subcommand: "GETKEYSANDFLAGS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "GETKEYSANDFLAGS"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 5.0.0
    -

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get array of specific Redis command details, or all when no argument is given.

    • group: server
    • complexity: O(N) where N is the number of commands to look up
    • since: 2.8.13
    -

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • +

    Parameters

    • subcommand: "INFO"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • Get an array of Redis command names

    • group: server
    • complexity: O(N) where N is the total number of Redis commands
    • since: 7.0.0
    -

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • moduleNameToken: "MODULE"
    • moduleName: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • categoryToken: "ACLCAT"
    • category: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • patternToken: "PATTERN"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

config

  • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]): Promise<unknown>
  • config(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • config(subcommand: "RESETSTAT", callback?: Callback<unknown>): Promise<unknown>
  • config(subcommand: "REWRITE", callback?: Callback<unknown>): Promise<unknown>
  • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]): Promise<unknown>
  • +

    Parameters

    • subcommand: "LIST"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • moduleNameToken: "MODULE"
    • moduleName: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • categoryToken: "ACLCAT"
    • category: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • patternToken: "PATTERN"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

config

  • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]): Promise<unknown>
  • config(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
  • config(subcommand: "RESETSTAT", callback?: Callback<unknown>): Promise<unknown>
  • config(subcommand: "REWRITE", callback?: Callback<unknown>): Promise<unknown>
  • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]): Promise<unknown>

  • Get the values of configuration parameters

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

    Returns Promise<unknown>

  • +

    Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 5.0.0
    -

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "HELP"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Reset the stats returned by INFO

    • group: server
    • complexity: O(1)
    • since: 2.0.0
    -

    Parameters

    • subcommand: "RESETSTAT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "RESETSTAT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Rewrite the configuration file with the in memory configuration

    • group: server
    • complexity: O(1)
    • since: 2.8.0
    -

    Parameters

    • subcommand: "REWRITE"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • +

    Parameters

    • subcommand: "REWRITE"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Set configuration parameters to the given values

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0
    -

    Parameters

    • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]

    Returns Promise<unknown>

connect

  • connect(): Promise<void>
  • +

    Parameters

    • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]

    Returns Promise<unknown>

connect

  • connect(): Promise<void>

copy

  • copy(source: RedisKey, destination: RedisKey, callback?: Callback<number>): Promise<number>
  • copy(source: RedisKey, destination: RedisKey, replace: "REPLACE", callback?: Callback<number>): Promise<number>
  • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, callback?: Callback<number>): Promise<number>
  • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, replace: "REPLACE", callback?: Callback<number>): Promise<number>

copy

  • copy(source: RedisKey, destination: RedisKey, callback?: Callback<number>): Promise<number>
  • copy(source: RedisKey, destination: RedisKey, replace: "REPLACE", callback?: Callback<number>): Promise<number>
  • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, callback?: Callback<number>): Promise<number>
  • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, replace: "REPLACE", callback?: Callback<number>): Promise<number>

  • Copy a key

    • group: generic
    • complexity: O(N) worst case for collections, where N is the number of nested items. O(1) for string values.
    • since: 6.2.0
    -

    Parameters

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • replace: "REPLACE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<number>

    Returns Promise<number>

createBuiltinCommand

  • createBuiltinCommand(commandName: string): { buffer: any; string: any }
  • +

    Parameters

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • replace: "REPLACE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<number>

    Returns Promise<number>

createBuiltinCommand

  • createBuiltinCommand(commandName: string): { buffer: any; string: any }

  • Create a builtin command

    -

    Parameters

    • commandName: string

    Returns { buffer: any; string: any }

    • buffer: any
    • string: any

dbsize

  • dbsize(callback?: Callback<number>): Promise<number>
  • +

    Parameters

    • commandName: string

    Returns { buffer: any; string: any }

    • buffer: any
    • string: any

dbsize

  • dbsize(callback?: Callback<number>): Promise<number>

  • Return the number of keys in the selected database

    • group: server
    • complexity: O(1)
    • since: 1.0.0
    -

    Parameters

    • Optional callback: Callback<number>

    Returns Promise<number>

debug

  • debug(subcommand: string, callback?: Callback<unknown>): Promise<unknown>
  • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

debug

  • debug(subcommand: string, callback?: Callback<unknown>): Promise<unknown>
  • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
  • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

  • A container for debugging commands

    • group: server
    • complexity: Depends on subcommand.
    • since: 1.0.0
    -

    Parameters

    • subcommand: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

decr

  • decr(key: RedisKey, callback?: Callback<number>): Promise<number>
  • +

    Parameters

    • subcommand: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

decr

  • decr(key: RedisKey, callback?: Callback<number>): Promise<number>

  • Decrement the integer value of a key by one

    • group: string
    • complexity: O(1)
    • since: 1.0.0
    -

    Parameters

    • key: RedisKey
    • Optional callback: Callback<number>

    Returns Promise<number>

decrby

  • decrby(key: RedisKey, decrement: string | number, callback?: Callback<number>): Promise<number>

decrby

  • decrby(key: RedisKey, decrement: string | number, callback?: Callback<number>): Promise<number>

  • Decrement the integer value of a key by the given number

    • group: string
    • complexity: O(1)
    • since: 1.0.0
    -

    Parameters

    • key: RedisKey
    • decrement: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

defineCommand

  • defineCommand(name: string, definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }): void
  • +

    Parameters

    • key: RedisKey
    • decrement: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

defineCommand

  • defineCommand(name: string, definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }): void

  • Define a custom command using lua script

    -

    Parameters

    • name: string
    • definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }
      • lua: string
      • Optional numberOfKeys?: number
      • Optional readOnly?: boolean

    Returns void

del

  • del(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • del(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • del(...args: RedisKey[]): Promise<number>
  • del(...args: [keys: RedisKey[]]): Promise<number>
  • +

    Parameters

    • name: string
    • definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }
      • lua: string
      • Optional numberOfKeys?: number
      • Optional readOnly?: boolean

    Returns void

del

  • del(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • del(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
  • del(...args: RedisKey[]): Promise<number>
  • del(...args: [keys: RedisKey[]]): Promise<number>

  • Delete a key

    • group: generic
    • complexity: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
    • since: 1.0.0
    -

    Parameters

    • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

discard

  • discard(callback?: Callback<"OK">): Promise<"OK">

discard

  • discard(callback?: Callback<"OK">): Promise<"OK">

  • Discard all commands issued after MULTI

    • group: transactions
    • complexity: O(N), when N is the number of queued commands
    • since: 2.0.0
    -

    Parameters

    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

disconnect

  • disconnect(reconnect?: boolean): void

disconnect

  • disconnect(reconnect?: boolean): void

  • Disconnect from every node in the cluster.

    -

    Parameters

    • reconnect: boolean = false

    Returns void

dump

  • dump(key: RedisKey, callback?: Callback<string>): Promise<string>

dump

  • dump(key: RedisKey, callback?: Callback<string>): Promise<string>

  • Return a serialized version of the value stored at the specified key.

    • group: generic
    • complexity: O(1) to access the key and additional O(NM) to serialize it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1).
    • since: 2.6.0
    -

    Parameters

    • key: RedisKey
    • Optional callback: Callback<string>

    Returns Promise<string>

dumpBuffer

  • dumpBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

duplicate

  • duplicate(overrideStartupNodes?: any[], overrideOptions?: {}): Cluster

dumpBuffer

  • dumpBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

duplicate

  • duplicate(overrideStartupNodes?: any[], overrideOptions?: {}): Cluster

  • Create a new instance with the same startup nodes and options as the current one.

    example
    var cluster = new Redis.Cluster([{ host: "127.0.0.1", port: "30001" }]);
    var anotherCluster = cluster.duplicate();
    -

    Parameters

    • overrideStartupNodes: any[] = []
    • overrideOptions: {} = {}

      Returns Cluster

    echo

    • echo(message: string | Buffer, callback?: Callback<string>): Promise<string>

    echo

    • echo(message: string | Buffer, callback?: Callback<string>): Promise<string>

    • Echo the given string

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    echoBuffer

    • echoBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    eval

    • eval(script: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    echoBuffer

    • echoBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    eval

    • eval(script: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 2.6.0
      -

      Parameters

      • script: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    eval_ro

    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • script: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    eval_ro

    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a read-only Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha

    • evalsha(sha1: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha

    • evalsha(sha1: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 2.6.0
      -

      Parameters

      • sha1: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha_ro

    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • sha1: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha_ro

    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a read-only Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    exec

    • exec(callback?: Callback<[error: Error, result: unknown][]>): Promise<[error: Error, result: unknown][]>
    • +

      Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    exec

    • exec(callback?: Callback<[error: Error, result: unknown][]>): Promise<[error: Error, result: unknown][]>

    • Execute all commands issued after MULTI

      • group: transactions
      • complexity: Depends on commands in the transaction
      • since: 1.2.0
      -

      Parameters

      • Optional callback: Callback<[error: Error, result: unknown][]>

      Returns Promise<[error: Error, result: unknown][]>

    exists

    • exists(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: RedisKey[]): Promise<number>
    • exists(...args: [keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<[error: Error, result: unknown][]>

      Returns Promise<[error: Error, result: unknown][]>

    exists

    • exists(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: RedisKey[]): Promise<number>
    • exists(...args: [keys: RedisKey[]]): Promise<number>

    expire

    • expire(key: RedisKey, seconds: string | number, callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    expire

    • expire(key: RedisKey, seconds: string | number, callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set a key's time to live in seconds

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • seconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expireat

    • expireat(key: RedisKey, unixTimeSeconds: string | number, callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • seconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expireat

    • expireat(key: RedisKey, unixTimeSeconds: string | number, callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set the expiration for a key as a UNIX timestamp

      • group: generic
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expiretime

    • expiretime(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expiretime

    • expiretime(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the expiration Unix timestamp for a key

      • group: generic
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    failover

    • failover(callback?: Callback<"OK">): Promise<"OK">
    • failover(millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">

    failover

    • failover(callback?: Callback<"OK">): Promise<"OK">
    • failover(millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Start a coordinated failover between this server and one of its replicas.

      • group: server
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    fcall

    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    fcall

    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Invoke a function

      • group: scripting
      • complexity: Depends on the function that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    fcall_ro

    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    fcall_ro

    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Invoke a read-only function

      • group: scripting
      • complexity: Depends on the function that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    flushall

    • flushall(callback?: Callback<"OK">): Promise<"OK">
    • flushall(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushall(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    flushall

    • flushall(callback?: Callback<"OK">): Promise<"OK">
    • flushall(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushall(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">

    • Remove all keys from all databases

      • group: server
      • complexity: O(N) where N is the total number of keys in all databases
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    flushdb

    • flushdb(callback?: Callback<"OK">): Promise<"OK">
    • flushdb(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushdb(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    flushdb

    • flushdb(callback?: Callback<"OK">): Promise<"OK">
    • flushdb(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushdb(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">

    • Remove all keys from the current database

      • group: server
      • complexity: O(N) where N is the number of keys in the selected database
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    function

    • function(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "DUMP", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • function(subcommand: "KILL", callback?: Callback<string>): Promise<string>
    • function(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<string>): Promise<string>
    • function(subcommand: "STATS", callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    function

    • function(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "DUMP", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • function(subcommand: "KILL", callback?: Callback<string>): Promise<string>
    • function(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<string>): Promise<string>
    • function(subcommand: "STATS", callback?: Callback<unknown>): Promise<unknown>

    • Delete a function by name

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Dump all functions into a serialized binary payload

      • group: scripting
      • complexity: O(N) where N is the number of functions
      • since: 7.0.0
      -

      Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Deleting all functions

      • group: scripting
      • complexity: O(N) where N is the number of functions deleted
      • since: 7.0.0
      -

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Show helpful text about the different subcommands

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Kill the function currently in execution.

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • List information about all the functions

      • group: scripting
      • complexity: O(N) where N is the number of functions
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Create a function with the given arguments (name, code, description)

      • group: scripting
      • complexity: O(1) (considering compilation time is redundant)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Restore all the functions on the given payload

      • group: scripting
      • complexity: O(N) where N is the number of functions on the payload
      • since: 7.0.0
      -

      Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Return information about the function currently running (name, description, duration)

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    functionBuffer

    • functionBuffer(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "DUMP", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "KILL", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geoadd

    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    functionBuffer

    • functionBuffer(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "DUMP", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "KILL", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geoadd

    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>

    • Add one or more geospatial items in the geospatial index represented using a sorted set

      • group: geo
      • complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    geodist

    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    geodist

    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<string>): Promise<string>

    • Returns the distance between two members of a geospatial index

      • group: geo
      • complexity: O(log(N))
      • since: 3.2.0
      -

      Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<string>

      Returns Promise<string>

    geodistBuffer

    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geohash

    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<string>

      Returns Promise<string>

    geodistBuffer

    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geohash

    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>

    • Returns members of a geospatial index as standard geohash strings

      • group: geo
      • complexity: O(log(N)) for each member requested, where N is the number of elements in the sorted set.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    geohashBuffer

    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    geopos

    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    geohashBuffer

    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    geopos

    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>

    • Returns longitude and latitude of members of a geospatial index

      • group: geo
      • complexity: O(N) where N is the number of members requested.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    georadius

    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    georadius

    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown[]>

    • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown[]>

    georadius_ro

    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown[]>

    georadius_ro

    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown>

    • A read-only variant for GEORADIUS

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.10
      -

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember

    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember

    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember_ro

    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember_ro

    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>

    • A read-only variant for GEORADIUSBYMEMBER

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.10
      -

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    geosearch

    • geosearch(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • geosearch(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<unknown[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    geosearch

    • geosearch(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • geosearch(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<unknown[]>

    • Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
      • since: 6.2.0
      -

      Parameters

      Returns Promise<unknown[]>

    • Parameters

      Returns Promise<unknown[]>

    geosearchstore

    geosearchstore

    • Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
      • since: 6.2.0
      -

      Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    get

    • get(key: RedisKey, callback?: Callback<string>): Promise<string>

    get

    • get(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Get the value of a key

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    getBuffer

    • getBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getBuiltinCommands

    • getBuiltinCommands(): string[]
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    getBuffer

    • getBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getBuiltinCommands

    • getBuiltinCommands(): string[]

    • Return supported builtin commands

      -

      Returns string[]

    getbit

    • getbit(key: RedisKey, offset: string | number, callback?: Callback<number>): Promise<number>

    getbit

    • getbit(key: RedisKey, offset: string | number, callback?: Callback<number>): Promise<number>

    • Returns the bit value at offset in the string value stored at key

      • group: bitmap
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • offset: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    getdel

    • getdel(key: RedisKey, callback?: Callback<string>): Promise<string>

    getdel

    • getdel(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Get the value of a key and delete the key

      • group: string
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    getdelBuffer

    • getdelBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getex

    • getex(key: RedisKey, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, persist: "PERSIST", callback?: Callback<string>): Promise<string>

    getdelBuffer

    • getdelBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getex

    • getex(key: RedisKey, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, persist: "PERSIST", callback?: Callback<string>): Promise<string>

    • Get the value of a key and optionally set its expiration

      • group: string
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<string>

      Returns Promise<string>

    getexBuffer

    • getexBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, persist: "PERSIST", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getrange

    • getrange(key: RedisKey, start: string | number, end: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<string>

      Returns Promise<string>

    getexBuffer

    • getexBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, persist: "PERSIST", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getrange

    • getrange(key: RedisKey, start: string | number, end: string | number, callback?: Callback<string>): Promise<string>

    • Get a substring of the string stored at a key

      • group: string
      • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
      • since: 2.4.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    getrangeBuffer

    • getrangeBuffer(key: RedisKey, start: string | number, end: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getset

    • getset(key: RedisKey, value: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    getrangeBuffer

    • getrangeBuffer(key: RedisKey, start: string | number, end: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getset

    • getset(key: RedisKey, value: string | number | Buffer, callback?: Callback<string>): Promise<string>

    • Set the string value of a key and return its old value

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    getsetBuffer

    • getsetBuffer(key: RedisKey, value: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hdel

    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    getsetBuffer

    • getsetBuffer(key: RedisKey, value: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hdel

    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<number>

    • Delete one or more hash fields

      • group: hash
      • complexity: O(N) where N is the number of fields to be removed.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<number>

    hello

    • hello(callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    hello

    • hello(callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    • Handshake with Redis

      • group: connection
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    hexists

    • hexists(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    hexists

    • hexists(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>

    • Determine if a hash field exists

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hget

    • hget(key: RedisKey, field: string | Buffer, callback?: Callback<string>): Promise<string>

    hget

    • hget(key: RedisKey, field: string | Buffer, callback?: Callback<string>): Promise<string>

    • Get the value of a hash field

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    hgetBuffer

    • hgetBuffer(key: RedisKey, field: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    hgetall

    • hgetall(key: RedisKey, callback?: Callback<Record<string, string>>): Promise<Record<string, string>>

    hgetBuffer

    • hgetBuffer(key: RedisKey, field: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    hgetall

    • hgetall(key: RedisKey, callback?: Callback<Record<string, string>>): Promise<Record<string, string>>

    • Get all the fields and values in a hash

      • group: hash
      • complexity: O(N) where N is the size of the hash.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, string>>

      Returns Promise<Record<string, string>>

    hgetallBuffer

    • hgetallBuffer(key: RedisKey, callback?: Callback<Record<string, Buffer>>): Promise<Record<string, Buffer>>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, Buffer>>

      Returns Promise<Record<string, Buffer>>

    hincrby

    • hincrby(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, string>>

      Returns Promise<Record<string, string>>

    hgetallBuffer

    • hgetallBuffer(key: RedisKey, callback?: Callback<Record<string, Buffer>>): Promise<Record<string, Buffer>>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, Buffer>>

      Returns Promise<Record<string, Buffer>>

    hincrby

    • hincrby(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<number>): Promise<number>

    • Increment the integer value of a hash field by the given number

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    hincrbyfloat

    • hincrbyfloat(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    hincrbyfloat

    • hincrbyfloat(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<string>): Promise<string>

    • Increment the float value of a hash field by the given amount

      • group: hash
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    hincrbyfloatBuffer

    • hincrbyfloatBuffer(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hkeys

    • hkeys(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    hincrbyfloatBuffer

    • hincrbyfloatBuffer(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hkeys

    • hkeys(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    • Get all the fields in a hash

      • group: hash
      • complexity: O(N) where N is the size of the hash.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    hkeysBuffer

    • hkeysBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    hlen

    • hlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    hkeysBuffer

    • hkeysBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    hlen

    • hlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the number of fields in a hash

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    hmget

    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<string[]>

    hmget

    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<string[]>

    • Get the values of all the given hash fields

      • group: hash
      • complexity: O(N) where N is the number of fields being requested.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<string[]>

    hmgetBuffer

    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<Buffer[]>

    hmset

    • hmset(key: RedisKey, object: object, callback?: Callback<"OK">): Promise<"OK">
    • hmset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<"OK">
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<string[]>

    hmgetBuffer

    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<Buffer[]>

    hmset

    • hmset(key: RedisKey, object: object, callback?: Callback<"OK">): Promise<"OK">
    • hmset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<"OK">

    • Set multiple hash fields to multiple values

      • group: hash
      • complexity: O(N) where N is the number of fields being set.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<"OK">

    hrandfield

    • hrandfield(key: RedisKey, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • +

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<"OK">

    hrandfield

    • hrandfield(key: RedisKey, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<string | unknown[]>): Promise<string | unknown[]>

    • Get one or multiple random fields from a hash

      • group: hash
      • complexity: O(N) where N is the number of fields returned
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    hrandfieldBuffer

    • hrandfieldBuffer(key: RedisKey, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    hscan

    • hscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    hrandfieldBuffer

    • hrandfieldBuffer(key: RedisKey, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    hscan

    • hscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate hash fields and associated values

      • group: hash
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
      • since: 2.8.0
      -

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    hscanBuffer

    • hscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    hscanBufferStream

    • hscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hscanStream

    • hscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hset

    • hset(key: RedisKey, object: object, callback?: Callback<number>): Promise<number>
    • hset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<number>): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    hscanBuffer

    • hscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    hscanBufferStream

    • hscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hscanStream

    • hscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hset

    • hset(key: RedisKey, object: object, callback?: Callback<number>): Promise<number>
    • hset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<number>): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<number>

    • Set the string value of a hash field

      • group: hash
      • complexity: O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<number>

    hsetnx

    • hsetnx(key: RedisKey, field: string | Buffer, value: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<number>

    hsetnx

    • hsetnx(key: RedisKey, field: string | Buffer, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Set the value of a hash field, only if the field does not exist

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hstrlen

    • hstrlen(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hstrlen

    • hstrlen(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>

    • Get the length of the value of a hash field

      • group: hash
      • complexity: O(1)
      • since: 3.2.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hvals

    • hvals(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    hvals

    • hvals(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    • Get all the values in a hash

      • group: hash
      • complexity: O(N) where N is the size of the hash.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    hvalsBuffer

    • hvalsBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    incr

    • incr(key: RedisKey, callback?: Callback<number>): Promise<number>

    hvalsBuffer

    • hvalsBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    incr

    • incr(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Increment the integer value of a key by one

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    incrby

    • incrby(key: RedisKey, increment: string | number, callback?: Callback<number>): Promise<number>

    incrby

    • incrby(key: RedisKey, increment: string | number, callback?: Callback<number>): Promise<number>

    • Increment the integer value of a key by the given amount

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    incrbyfloat

    • incrbyfloat(key: RedisKey, increment: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    incrbyfloat

    • incrbyfloat(key: RedisKey, increment: string | number, callback?: Callback<string>): Promise<string>

    • Increment the float value of a key by the given amount

      • group: string
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • increment: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    info

    • info(callback?: Callback<string>): Promise<string>
    • info(...args: [...sections: (string | Buffer)[], callback: Callback<string>]): Promise<string>
    • info(...args: (string | Buffer)[]): Promise<string>

    info

    • info(callback?: Callback<string>): Promise<string>
    • info(...args: [...sections: (string | Buffer)[], callback: Callback<string>]): Promise<string>
    • info(...args: (string | Buffer)[]): Promise<string>

    • Get information and statistics about the server

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • Rest ...args: [...sections: (string | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<string>

    keys

    • keys(pattern: string, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • Rest ...args: [...sections: (string | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<string>

    keys

    • keys(pattern: string, callback?: Callback<string[]>): Promise<string[]>

    • Find all keys matching the given pattern

      • group: generic
      • complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
      • since: 1.0.0
      -

      Parameters

      • pattern: string
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    keysBuffer

    • keysBuffer(pattern: string, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • pattern: string
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lastsave

    • lastsave(callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • pattern: string
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    keysBuffer

    • keysBuffer(pattern: string, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • pattern: string
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lastsave

    • lastsave(callback?: Callback<number>): Promise<number>

    • Get the UNIX time stamp of the last successful save to disk

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<number>

      Returns Promise<number>

    latency

    • latency(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • latency(subcommand: "GRAPH", event: string | Buffer, callback?: Callback<string>): Promise<string>
    • latency(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "HISTOGRAM", callback?: Callback<unknown>): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]): Promise<unknown>
    • latency(subcommand: "HISTORY", event: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "LATEST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "RESET", callback?: Callback<number>): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<number>

      Returns Promise<number>

    latency

    • latency(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • latency(subcommand: "GRAPH", event: string | Buffer, callback?: Callback<string>): Promise<string>
    • latency(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "HISTOGRAM", callback?: Callback<unknown>): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]): Promise<unknown>
    • latency(subcommand: "HISTORY", event: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "LATEST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "RESET", callback?: Callback<number>): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[]]): Promise<number>

    • Return a human readable latency analysis report.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Return a latency graph for the event.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "GRAPH"
      • event: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "GRAPH"
      • event: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Show helpful text about the different subcommands.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Return the cumulative distribution of latencies of a subset of commands or all.

      • group: server
      • complexity: O(N) where N is the number of commands with latency information being retrieved.
      • since: 7.0.0
      -

      Parameters

      • subcommand: "HISTOGRAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HISTOGRAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

      Returns Promise<unknown>

    • Return timestamp-latency samples for the event.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "HISTORY"
      • event: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HISTORY"
      • event: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Return the latest latency samples for all events.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "LATEST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "LATEST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Reset latency data for one or more events.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

      Returns Promise<number>

    lcs

    • lcs(key1: RedisKey, key2: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

      Returns Promise<number>

    lcs

    • lcs(key1: RedisKey, key2: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>

    lindex

    • lindex(key: RedisKey, index: string | number, callback?: Callback<string>): Promise<string>

    lindex

    • lindex(key: RedisKey, index: string | number, callback?: Callback<string>): Promise<string>

    • Get an element from a list by its index

      • group: list
      • complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • index: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    lindexBuffer

    • lindexBuffer(key: RedisKey, index: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    linsert

    • linsert(key: RedisKey, before: "BEFORE", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • linsert(key: RedisKey, after: "AFTER", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>

    lindexBuffer

    • lindexBuffer(key: RedisKey, index: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    linsert

    • linsert(key: RedisKey, before: "BEFORE", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • linsert(key: RedisKey, after: "AFTER", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Insert an element before or after another element in a list

      • group: list
      • complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • before: "BEFORE"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • after: "AFTER"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    llen

    • llen(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • before: "BEFORE"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • after: "AFTER"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    llen

    • llen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the length of a list

      • group: list
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    lmove

    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<string>): Promise<string>

    lmove

    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<string>): Promise<string>

    • Pop an element from a list, push it to another list and return it

      • group: list
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • left1: "LEFT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • right: "RIGHT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • left: "LEFT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • right1: "RIGHT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    lmoveBuffer

    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>

    lmpop

    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>

    lmoveBuffer

    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>

    lmpop

    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>

    • Pop elements from a list

      • group: list
      • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    lmpopBuffer

    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    lolwut

    • lolwut(callback?: Callback<string>): Promise<string>
    • lolwut(versionToken: "VERSION", version: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    lmpopBuffer

    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    lolwut

    • lolwut(callback?: Callback<string>): Promise<string>
    • lolwut(versionToken: "VERSION", version: string | number, callback?: Callback<string>): Promise<string>

    • Display some computer art and the Redis version

      • group: server
      • complexity: undefined
      • since: 5.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • versionToken: "VERSION"
      • version: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    lpop

    • lpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • lpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • versionToken: "VERSION"
      • version: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    lpop

    • lpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • lpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and get the first elements in a list

      • group: list
      • complexity: O(N) where N is the number of elements returned
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    lpopBuffer

    • lpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • lpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    lpos

    • lpos(key: RedisKey, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>

    lpopBuffer

    • lpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • lpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    lpos

    • lpos(key: RedisKey, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>

    • Return the index of matching elements on a list

      • group: list
      • complexity: O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.
      • since: 6.0.6
      -

      Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    lpush

    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    lpush

    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Prepend one or multiple elements to a list

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lpushx

    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lpushx

    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Prepend an element to a list, only if the list exists

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 2.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lrange

    • lrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lrange

    • lrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Get a range of elements from a list

      • group: list
      • complexity: O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    lrangeBuffer

    • lrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lrem

    • lrem(key: RedisKey, count: string | number, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    lrangeBuffer

    • lrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lrem

    • lrem(key: RedisKey, count: string | number, element: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Remove elements from a list

      • group: list
      • complexity: O(N+M) where N is the length of the list and M is the number of elements removed.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • count: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    lset

    • lset(key: RedisKey, index: string | number, element: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • count: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    lset

    • lset(key: RedisKey, index: string | number, element: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">

    • Set the value of an element in a list by its index

      • group: list
      • complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • index: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    ltrim

    • ltrim(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • index: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    ltrim

    • ltrim(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Trim a list to the specified range

      • group: list
      • complexity: O(N) where N is the number of elements to be removed by the operation.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    memory

    • memory(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "MALLOC-STATS", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "PURGE", callback?: Callback<"OK">): Promise<"OK">
    • memory(subcommand: "STATS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "USAGE", key: RedisKey, callback?: Callback<number>): Promise<number>
    • memory(subcommand: "USAGE", key: RedisKey, countToken: "SAMPLES", count: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    memory

    • memory(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "MALLOC-STATS", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "PURGE", callback?: Callback<"OK">): Promise<"OK">
    • memory(subcommand: "STATS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "USAGE", key: RedisKey, callback?: Callback<number>): Promise<number>
    • memory(subcommand: "USAGE", key: RedisKey, countToken: "SAMPLES", count: string | number, callback?: Callback<number>): Promise<number>

    • Outputs memory problems report

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Show allocator internal stats

      • group: server
      • complexity: Depends on how much memory is allocated, could be slow
      • since: 4.0.0
      -

      Parameters

      • subcommand: "MALLOC-STATS"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "MALLOC-STATS"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Ask the allocator to release memory

      • group: server
      • complexity: Depends on how much memory is allocated, could be slow
      • since: 4.0.0
      -

      Parameters

      • subcommand: "PURGE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "PURGE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Show memory usage details

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Estimate the memory usage of a key

      • group: server
      • complexity: O(N) where N is the number of samples.
      • since: 4.0.0
      -

      Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • countToken: "SAMPLES"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    mget

    • mget(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: RedisKey[]): Promise<string[]>
    • mget(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • countToken: "SAMPLES"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    mget

    • mget(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: RedisKey[]): Promise<string[]>
    • mget(...args: [keys: RedisKey[]]): Promise<string[]>

    • Get the values of all the given keys

      • group: string
      • complexity: O(N) where N is the number of keys to retrieve.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    mgetBuffer

    • mgetBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    migrate

    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]): Promise<"OK">
    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]): Promise<"OK">

    mgetBuffer

    • mgetBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    migrate

    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]): Promise<"OK">
    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]): Promise<"OK">

    • Atomically transfer a key from a Redis instance to another one.

      • group: generic
      • complexity: This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
      • since: 2.6.0
      -

      Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]

      Returns Promise<"OK">

    module

    • module(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LOAD", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(subcommand: "LOADEX", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]): Promise<unknown>
    • module(subcommand: "UNLOAD", name: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]

      Returns Promise<"OK">

    module

    • module(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LOAD", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(subcommand: "LOADEX", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]): Promise<unknown>
    • module(subcommand: "UNLOAD", name: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List all modules loaded by the server

      • group: server
      • complexity: O(N) where N is the number of loaded modules.
      • since: 4.0.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Load a module

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "LOAD"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LOAD"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Load a module with extended parameters

      • group: server
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LOADEX"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LOADEX"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

      Returns Promise<unknown>

    • Unload a module

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "UNLOAD"
      • name: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    move

    • move(key: RedisKey, db: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • subcommand: "UNLOAD"
      • name: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    move

    • move(key: RedisKey, db: string | number, callback?: Callback<number>): Promise<number>

    • Move a key to another database

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • db: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    mset

    • mset(object: object, callback?: Callback<"OK">): Promise<"OK">
    • mset(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • mset(...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]): Promise<"OK">
    • mset(...args: (number | RedisKey)[]): Promise<"OK">

    mset

    • mset(object: object, callback?: Callback<"OK">): Promise<"OK">
    • mset(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • mset(...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]): Promise<"OK">
    • mset(...args: (number | RedisKey)[]): Promise<"OK">

    • Set multiple keys to multiple values

      • group: string
      • complexity: O(N) where N is the number of keys to set.
      • since: 1.0.1
      -

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      Returns Promise<"OK">

    msetnx

    • msetnx(object: object, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]): Promise<number>
    • msetnx(...args: (number | RedisKey)[]): Promise<number>
    • +

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      Returns Promise<"OK">

    msetnx

    • msetnx(object: object, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]): Promise<number>
    • msetnx(...args: (number | RedisKey)[]): Promise<number>

    • Set multiple keys to multiple values, only if none of the keys exist

      • group: string
      • complexity: O(N) where N is the number of keys to set.
      • since: 1.0.1
      -

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    multi

    nodes

    • +

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    multi

    nodes

    object

    • object(subcommand: "ENCODING", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "FREQ", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "IDLETIME", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "REFCOUNT", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    object

    • object(subcommand: "ENCODING", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "FREQ", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "IDLETIME", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "REFCOUNT", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    • Inspect the internal encoding of a Redis object

      • group: generic
      • complexity: O(1)
      • since: 2.2.3
      -

      Parameters

      • subcommand: "ENCODING"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "ENCODING"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the logarithmic access frequency counter of a Redis object

      • group: generic
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "FREQ"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "FREQ"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: generic
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the time since a Redis object was last accessed

      • group: generic
      • complexity: O(1)
      • since: 2.2.3
      -

      Parameters

      • subcommand: "IDLETIME"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "IDLETIME"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the number of references to the value of the key

      • group: generic
      • complexity: O(1)
      • since: 2.2.3
      -

      Parameters

      • subcommand: "REFCOUNT"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    persist

    • persist(key: RedisKey, callback?: Callback<number>): Promise<number>

    persist

    • persist(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Remove the expiration from a key

      • group: generic
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpire

    • pexpire(key: RedisKey, milliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    pexpire

    • pexpire(key: RedisKey, milliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set a key's time to live in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpireat

    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpireat

    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set the expiration for a key as a UNIX timestamp specified in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpiretime

    • pexpiretime(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpiretime

    • pexpiretime(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the expiration Unix timestamp for a key in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    pfadd

    • pfadd(key: RedisKey, callback?: Callback<number>): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    pfadd

    • pfadd(key: RedisKey, callback?: Callback<number>): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Adds the specified elements to the specified HyperLogLog.

      • group: hyperloglog
      • complexity: O(1) to add every element.
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    pfcount

    • pfcount(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: RedisKey[]): Promise<number>
    • pfcount(...args: [keys: RedisKey[]]): Promise<number>

    pfcount

    • pfcount(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: RedisKey[]): Promise<number>
    • pfcount(...args: [keys: RedisKey[]]): Promise<number>

    • Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

      • group: hyperloglog
      • complexity: O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.
      • since: 2.8.9
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    pfdebug

    • pfdebug(subcommand: string | Buffer, key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    pfdebug

    • pfdebug(subcommand: string | Buffer, key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    • Internal commands for debugging HyperLogLog values

      • group: hyperloglog
      • complexity: N/A
      • since: 2.8.9
      -

      Parameters

      • subcommand: string | Buffer
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pfmerge

    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[]]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[]]): Promise<"OK">
    • +

      Parameters

      • subcommand: string | Buffer
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pfmerge

    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[]]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[]]): Promise<"OK">

    pfselftest

    • pfselftest(callback?: Callback<unknown>): Promise<unknown>

    pfselftest

    • pfselftest(callback?: Callback<unknown>): Promise<unknown>

    • An internal command for testing HyperLogLog values

      • group: hyperloglog
      • complexity: N/A
      • since: 2.8.9
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    ping

    • ping(callback?: Callback<"PONG">): Promise<"PONG">
    • ping(message: string | Buffer, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    ping

    • ping(callback?: Callback<"PONG">): Promise<"PONG">
    • ping(message: string | Buffer, callback?: Callback<string>): Promise<string>

    • Ping the server

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"PONG">

      Returns Promise<"PONG">

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    pingBuffer

    • pingBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    pipeline

    psetex

    • psetex(key: RedisKey, milliseconds: string | number, value: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Optional callback: Callback<"PONG">

      Returns Promise<"PONG">

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    pingBuffer

    • pingBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    pipeline

    psetex

    • psetex(key: RedisKey, milliseconds: string | number, value: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Set the value and expiration in milliseconds of a key

      • group: string
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    psubscribe

    • psubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • psubscribe(...args: string[]): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    psubscribe

    • psubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • psubscribe(...args: string[]): Promise<unknown>

    • Listen for messages published to channels matching the given patterns

      • group: pubsub
      • complexity: O(N) where N is the number of patterns the client is already subscribed to.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    psync

    • psync(replicationid: string | number | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    psync

    • psync(replicationid: string | number | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Internal command used for replication

      • group: server
      • complexity: undefined
      • since: 2.8.0
      -

      Parameters

      • replicationid: string | number | Buffer
      • offset: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pttl

    • pttl(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • replicationid: string | number | Buffer
      • offset: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pttl

    • pttl(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the time to live for a key in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    publish

    • publish(channel: string | Buffer, message: string | Buffer, callback?: Callback<number>): Promise<number>

    publish

    • publish(channel: string | Buffer, message: string | Buffer, callback?: Callback<number>): Promise<number>

    • Post a message to a channel

      • group: pubsub
      • complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).
      • since: 2.0.0
      -

      Parameters

      • channel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    pubsub

    • pubsub(subcommand: "CHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "CHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMPAT", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDNUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]): Promise<unknown[]>
    • +

      Parameters

      • channel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    pubsub

    • pubsub(subcommand: "CHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "CHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMPAT", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDNUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]): Promise<unknown[]>

    • List active channels

      • group: pubsub
      • complexity: O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)
      • since: 2.8.0
      -

      Parameters

      • subcommand: "CHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "CHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "CHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "CHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Show helpful text about the different subcommands

      • group: pubsub
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get the count of unique patterns pattern subscriptions

      • group: pubsub
      • complexity: O(1)
      • since: 2.8.0
      -

      Parameters

      • subcommand: "NUMPAT"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "NUMPAT"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get the count of subscribers for channels

      • group: pubsub
      • complexity: O(N) for the NUMSUB subcommand, where N is the number of requested channels
      • since: 2.8.0
      -

      Parameters

      • subcommand: "NUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "NUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • List active shard channels

      • group: pubsub
      • complexity: O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).
      • since: 7.0.0
      -

      Parameters

      • subcommand: "SHARDCHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "SHARDCHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "SHARDCHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "SHARDCHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get the count of subscribers for shard channels

      • group: pubsub
      • complexity: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels
      • since: 7.0.0
      -

      Parameters

      • subcommand: "SHARDNUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    punsubscribe

    • punsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • punsubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • punsubscribe(...args: string[]): Promise<unknown>
    • +

      Parameters

      • subcommand: "SHARDNUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    punsubscribe

    • punsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • punsubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • punsubscribe(...args: string[]): Promise<unknown>

    • Stop listening for messages posted to channels matching the given patterns

      • group: pubsub
      • complexity: O(N+M) where N is the number of patterns the client is already subscribed and M is the number of total patterns subscribed in the system (by any client).
      • since: 2.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    quit

    • quit(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    quit

    • quit(callback?: Callback<"OK">): Promise<"OK">

    • Quit the cluster gracefully.

      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    randomkey

    • randomkey(callback?: Callback<string>): Promise<string>

    randomkey

    • randomkey(callback?: Callback<string>): Promise<string>

    • Return a random key from the keyspace

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    randomkeyBuffer

    • randomkeyBuffer(callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    readonly

    • readonly(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    randomkeyBuffer

    • randomkeyBuffer(callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    readonly

    • readonly(callback?: Callback<"OK">): Promise<"OK">

    • Enables read queries for a connection to a cluster replica node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    readwrite

    • readwrite(callback?: Callback<"OK">): Promise<"OK">

    readwrite

    • readwrite(callback?: Callback<"OK">): Promise<"OK">

    • Disables read queries for a connection to a cluster replica node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    rename

    • rename(key: RedisKey, newkey: RedisKey, callback?: Callback<"OK">): Promise<"OK">

    rename

    • rename(key: RedisKey, newkey: RedisKey, callback?: Callback<"OK">): Promise<"OK">

    • Rename a key

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      Returns Promise<"OK">

    renamenx

    • renamenx(key: RedisKey, newkey: RedisKey, callback?: Callback<number>): Promise<number>

    renamenx

    • renamenx(key: RedisKey, newkey: RedisKey, callback?: Callback<number>): Promise<number>

    • Rename a key, only if the new key does not exist

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      Returns Promise<number>

    replconf

    • replconf(callback?: Callback<unknown>): Promise<unknown>

    replconf

    • replconf(callback?: Callback<unknown>): Promise<unknown>

    • An internal command for configuring the replication stream

      • group: server
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    replicaof

    • replicaof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    replicaof

    • replicaof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Make the server a replica of another instance, or promote it as master.

      • group: server
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    reset

    • reset(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    reset

    • reset(callback?: Callback<"OK">): Promise<"OK">

    • Reset the connection

      • group: connection
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    restore

    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">

    restore

    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Create a key using the provided serialized value, previously obtained using DUMP.

      • group: generic
      • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    restore-asking

    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    restore-asking

    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>

    • An internal command for migrating keys in a cluster

      • group: server
      • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
      • since: 3.0.0
      -

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    role

    • role(callback?: Callback<unknown[]>): Promise<unknown[]>
    • +

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    role

    • role(callback?: Callback<unknown[]>): Promise<unknown[]>

    • Return the role of the instance in the context of replication

      • group: server
      • complexity: O(1)
      • since: 2.8.12
      -

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    rpop

    • rpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • rpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    rpop

    • rpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • rpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and get the last elements in a list

      • group: list
      • complexity: O(N) where N is the number of elements returned
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    rpopBuffer

    • rpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • rpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    rpoplpush

    • rpoplpush(source: RedisKey, destination: RedisKey, callback?: Callback<string>): Promise<string>

    rpopBuffer

    • rpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • rpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    rpoplpush

    • rpoplpush(source: RedisKey, destination: RedisKey, callback?: Callback<string>): Promise<string>

    • Remove the last element in a list, prepend it to another list and return it

      • group: list
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      Returns Promise<string>

    rpoplpushBuffer

    • rpoplpushBuffer(source: RedisKey, destination: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    rpush

    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    rpoplpushBuffer

    • rpoplpushBuffer(source: RedisKey, destination: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    rpush

    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Append one or multiple elements to a list

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    rpushx

    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    rpushx

    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Append an element to a list, only if the list exists

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 2.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    sadd

    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    sadd

    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    • Add one or more members to a set

      • group: set
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    save

    • save(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    save

    • save(callback?: Callback<"OK">): Promise<"OK">

    • Synchronously save the dataset to disk

      • group: server
      • complexity: O(N) where N is the total number of keys in all databases
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    scan

    • scan(cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    scan

    • scan(cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate the keys space

      • group: generic
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
      • since: 2.8.0
      -

      Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    scanBuffer

    • scanBuffer(cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    scard

    • scard(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    scanBuffer

    • scanBuffer(cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    scard

    • scard(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the number of members in a set

      • group: set
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    script

    • script(subcommand: "DEBUG", yes: "YES", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", no: "NO", callback?: Callback<unknown>): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]): Promise<unknown>
    • script(subcommand: "FLUSH", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "KILL", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "LOAD", script: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    script

    • script(subcommand: "DEBUG", yes: "YES", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", no: "NO", callback?: Callback<unknown>): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]): Promise<unknown>
    • script(subcommand: "FLUSH", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "KILL", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "LOAD", script: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Set the debug mode for executed scripts.

      • group: scripting
      • complexity: O(1)
      • since: 3.2.0
      -

      Parameters

      • subcommand: "DEBUG"
      • yes: "YES"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • no: "NO"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "DEBUG"
      • yes: "YES"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • no: "NO"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Check existence of scripts in the script cache.

      • group: scripting
      • complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
      • since: 2.6.0
      -

      Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

      Returns Promise<unknown>

    • Remove all the scripts from the script cache.

      • group: scripting
      • complexity: O(N) with N being the number of scripts in cache
      • since: 2.6.0
      -

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: scripting
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Kill the script currently in execution.

      • group: scripting
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Load the specified Lua script into the script cache.

      • group: scripting
      • complexity: O(N) with N being the length in bytes of the script body.
      • since: 2.6.0
      -

      Parameters

      • subcommand: "LOAD"
      • script: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sdiff

    • sdiff(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: RedisKey[]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • subcommand: "LOAD"
      • script: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sdiff

    • sdiff(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: RedisKey[]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[]]): Promise<string[]>

    • Subtract multiple sets

      • group: set
      • complexity: O(N) where N is the total number of elements in all given sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    sdiffBuffer

    • sdiffBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sdiffstore

    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    sdiffBuffer

    • sdiffBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sdiffstore

    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    select

    • select(index: string | number, callback?: Callback<"OK">): Promise<"OK">

    select

    • select(index: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Change the selected database for the current connection

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • index: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    set

    • set(key: RedisKey, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • index: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    set

    • set(key: RedisKey, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>

    • Set the string value of a key

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    setBuffer

    • setBuffer(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    setbit

    • setbit(key: RedisKey, offset: string | number, value: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    setBuffer

    • setBuffer(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    setbit

    • setbit(key: RedisKey, offset: string | number, value: string | number, callback?: Callback<number>): Promise<number>

    • Sets or clears the bit at offset in the string value stored at key

      • group: bitmap
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    setex

    • setex(key: RedisKey, seconds: string | number, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    setex

    • setex(key: RedisKey, seconds: string | number, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">

    • Set the value and expiration of a key

      • group: string
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • seconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    setnx

    • setnx(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • seconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    setnx

    • setnx(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Set the value of a key, only if the key does not exist

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    setrange

    • setrange(key: RedisKey, offset: string | number, value: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    setrange

    • setrange(key: RedisKey, offset: string | number, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Overwrite part of a string at key starting at the specified offset

      • group: string
      • complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    shutdown

    • shutdown(callback?: Callback<"OK">): Promise<"OK">
    • shutdown(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    shutdown

    • shutdown(callback?: Callback<"OK">): Promise<"OK">
    • shutdown(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">

    • Synchronously save the dataset to disk and then shut down the server

      • group: server
      • complexity: O(N) when saving, where N is the total number of keys in all databases when saving data, otherwise O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sinter

    • sinter(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: RedisKey[]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sinter

    • sinter(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: RedisKey[]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[]]): Promise<string[]>

    • Intersect multiple sets

      • group: set
      • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    sinterBuffer

    • sinterBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sintercard

    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>

    sinterBuffer

    • sinterBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sintercard

    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>

    • Intersect multiple sets and return the cardinality of the result

      • group: set
      • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    sinterstore

    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    sinterstore

    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    • Intersect multiple sets and store the resulting set in a key

      • group: set
      • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    sismember

    • sismember(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    sismember

    • sismember(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Determine if a given value is a member of a set

      • group: set
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    slaveof

    • slaveof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    slaveof

    • slaveof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Make the server a replica of another instance, or promote it as master.

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    slowlog

    • slowlog(subcommand: "GET", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "GET", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "RESET", callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    slowlog

    • slowlog(subcommand: "GET", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "GET", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "RESET", callback?: Callback<unknown>): Promise<unknown>

    • Get the slow log's entries

      • group: server
      • complexity: O(N) where N is the number of entries returned
      • since: 2.2.12
      -

      Parameters

      • subcommand: "GET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "GET"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "GET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "GET"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the slow log's length

      • group: server
      • complexity: O(1)
      • since: 2.2.12
      -

      Parameters

      • subcommand: "LEN"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LEN"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Clear all entries from the slow log

      • group: server
      • complexity: O(N) where N is the number of entries in the slowlog
      • since: 2.2.12
      -

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    smembers

    • smembers(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    smembers

    • smembers(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    • Get all the members in a set

      • group: set
      • complexity: O(N) where N is the set cardinality.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    smembersBuffer

    • smembersBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    smismember

    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number[]>

    smembersBuffer

    • smembersBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    smismember

    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number[]>

    • Returns the membership associated with the given elements for a set

      • group: set
      • complexity: O(N) where N is the number of elements being checked for membership
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    smove

    • smove(source: RedisKey, destination: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    smove

    • smove(source: RedisKey, destination: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Move a member from one set to another

      • group: set
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    sort

    sort

    • Sort the elements in a list, set or sorted set

      • group: generic
      • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
      • since: 1.0.0
      -

      Parameters

      Returns Promise<unknown>

    • Parameters

      Returns Promise<unknown>

    sort_ro

    • sort_ro(key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>

    sort_ro

    • sort_ro(key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>

    • Sort the elements in a list, set or sorted set. Read-only variant of SORT.

      • group: generic
      • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
      • since: 7.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    spop

    • spop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • spop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    spop

    • spop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • spop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and return one or multiple random members from a set

      • group: set
      • complexity: Without the count argument O(1), otherwise O(N) where N is the value of the passed count.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    spopBuffer

    • spopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • spopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    spublish

    • spublish(shardchannel: string | Buffer, message: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    spopBuffer

    • spopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • spopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    spublish

    • spublish(shardchannel: string | Buffer, message: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Post a message to a shard channel

      • group: pubsub
      • complexity: O(N) where N is the number of clients subscribed to the receiving shard channel.
      • since: 7.0.0
      -

      Parameters

      • shardchannel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    srandmember

    • srandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • srandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • shardchannel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    srandmember

    • srandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • srandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Get one or multiple random members from a set

      • group: set
      • complexity: Without the count argument O(1), otherwise O(N) where N is the absolute value of the passed count.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    srandmemberBuffer

    • srandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • srandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    srem

    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    srandmemberBuffer

    • srandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • srandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    srem

    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    • Remove one or more members from a set

      • group: set
      • complexity: O(N) where N is the number of members to be removed.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    sscan

    • sscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    sscan

    • sscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate Set elements

      • group: set
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
      • since: 2.8.0
      -

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    sscanBuffer

    • sscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    sscanBufferStream

    • sscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    sscanStream

    • sscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    ssubscribe

    • ssubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • ssubscribe(...args: (string | Buffer)[]): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    sscanBuffer

    • sscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    sscanBufferStream

    • sscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    sscanStream

    • sscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    ssubscribe

    • ssubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • ssubscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Listen for messages published to the given shard channels

      • group: pubsub
      • complexity: O(N) where N is the number of shard channels to subscribe to.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    strlen

    • strlen(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    strlen

    • strlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the length of the value stored in a key

      • group: string
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    subscribe

    • subscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • subscribe(...args: (string | Buffer)[]): Promise<unknown>

    subscribe

    • subscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • subscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Listen for messages published to the given channels

      • group: pubsub
      • complexity: O(N) where N is the number of channels to subscribe to.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    substr

    • substr(key: RedisKey, start: string | number, end: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    substr

    • substr(key: RedisKey, start: string | number, end: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Get a substring of the string stored at a key

      • group: string
      • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sunion

    • sunion(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: RedisKey[]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sunion

    • sunion(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: RedisKey[]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[]]): Promise<string[]>

    • Add multiple sets

      • group: set
      • complexity: O(N) where N is the total number of elements in all given sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    sunionBuffer

    • sunionBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sunionstore

    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    sunionBuffer

    • sunionBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sunionstore

    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    sunsubscribe

    • sunsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • sunsubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • sunsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    sunsubscribe

    • sunsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • sunsubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • sunsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Stop listening for messages posted to the given shard channels

      • group: pubsub
      • complexity: O(N) where N is the number of clients already subscribed to a shard channel.
      • since: 7.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    swapdb

    • swapdb(index1: string | number, index2: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    swapdb

    • swapdb(index1: string | number, index2: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Swaps two Redis databases

      • group: server
      • complexity: O(N) where N is the count of clients watching or blocking on keys from both databases.
      • since: 4.0.0
      -

      Parameters

      • index1: string | number
      • index2: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sync

    • sync(callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • index1: string | number
      • index2: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sync

    • sync(callback?: Callback<unknown>): Promise<unknown>

    • Internal command used for replication

      • group: server
      • complexity: undefined
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    time

    • time(callback?: Callback<number[]>): Promise<number[]>
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    time

    • time(callback?: Callback<number[]>): Promise<number[]>

    • Return the current server time

      • group: server
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    touch

    • touch(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: RedisKey[]): Promise<number>
    • touch(...args: [keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    touch

    • touch(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: RedisKey[]): Promise<number>
    • touch(...args: [keys: RedisKey[]]): Promise<number>

    • Alters the last access time of a key(s). Returns the number of existing keys specified.

      • group: generic
      • complexity: O(N) where N is the number of keys that will be touched.
      • since: 3.2.1
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    ttl

    • ttl(key: RedisKey, callback?: Callback<number>): Promise<number>

    ttl

    • ttl(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the time to live for a key in seconds

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    type

    • type(key: RedisKey, callback?: Callback<string>): Promise<string>

    type

    • type(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Determine the type stored at key

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    unlink

    • unlink(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: RedisKey[]): Promise<number>
    • unlink(...args: [keys: RedisKey[]]): Promise<number>

    unlink

    • unlink(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: RedisKey[]): Promise<number>
    • unlink(...args: [keys: RedisKey[]]): Promise<number>

    • Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

      • group: generic
      • complexity: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
      • since: 4.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    unsubscribe

    • unsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • unsubscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • unsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    unsubscribe

    • unsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • unsubscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • unsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Stop listening for messages posted to the given channels

      • group: pubsub
      • complexity: O(N) where N is the number of clients already subscribed to a channel.
      • since: 2.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    unwatch

    • unwatch(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    unwatch

    • unwatch(callback?: Callback<"OK">): Promise<"OK">

    • Forget about all watched keys

      • group: transactions
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    wait

    • wait(numreplicas: string | number, timeout: string | number, callback?: Callback<number>): Promise<number>

    wait

    • wait(numreplicas: string | number, timeout: string | number, callback?: Callback<number>): Promise<number>

    • Wait for the synchronous replication of all the write commands sent in the context of the current connection

      • group: generic
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • numreplicas: string | number
      • timeout: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    watch

    • watch(...args: [...keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: [keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: RedisKey[]): Promise<"OK">
    • watch(...args: [keys: RedisKey[]]): Promise<"OK">
    • +

      Parameters

      • numreplicas: string | number
      • timeout: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    watch

    • watch(...args: [...keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: [keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: RedisKey[]): Promise<"OK">
    • watch(...args: [keys: RedisKey[]]): Promise<"OK">

    xack

    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]): Promise<number>

    xack

    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]): Promise<number>

    • Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.

      • group: stream
      • complexity: O(1) for each message ID processed.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xadd

    • +

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xadd

    • Appends a new entry to a stream

      • group: stream
      • complexity: O(1) when adding a new entry, O(N) when trimming where N being the number of entries evicted.
      • since: 5.0.0
      -

      Parameters

      Returns Promise<string>

    • Parameters

      Returns Promise<string>

    xaddBuffer

    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<Buffer>]): Promise<Buffer>
    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<Buffer>

    xautoclaim

    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>

    xaddBuffer

    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<Buffer>]): Promise<Buffer>
    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<Buffer>

    xautoclaim

    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>

    • Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.

      • group: stream
      • complexity: O(1) if COUNT is small.
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xclaim

    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • +

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xclaim

    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>

    • Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.

      • group: stream
      • complexity: O(log N) with N being the number of messages in the PEL of the consumer group.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    xdel

    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    xdel

    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]): Promise<number>

    • Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.

      • group: stream
      • complexity: O(1) for each single item to delete in the stream, regardless of the stream size.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xgroup

    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATECONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DELCONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DESTROY", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xgroup

    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATECONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DELCONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DESTROY", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Create a consumer group.

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Create a consumer in a consumer group.

      • group: stream
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "CREATECONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CREATECONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Delete a consumer from a consumer group.

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "DELCONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "DELCONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Destroy a consumer group.

      • group: stream
      • complexity: O(N) where N is the number of entries in the group's pending entries list (PEL).
      • since: 5.0.0
      -

      Parameters

      • subcommand: "DESTROY"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "DESTROY"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Set a consumer group to an arbitrary last delivered ID value.

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xinfo

    • xinfo(subcommand: "CONSUMERS", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "GROUPS", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", countToken: "COUNT", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xinfo

    • xinfo(subcommand: "CONSUMERS", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "GROUPS", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", countToken: "COUNT", count: string | number, callback?: Callback<unknown>): Promise<unknown>

    • List the consumers in a consumer group

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "CONSUMERS"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CONSUMERS"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List the consumer groups of a stream

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "GROUPS"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "GROUPS"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get information about a stream

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xlen

    • xlen(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xlen

    • xlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Return the number of entries in a stream

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    xpending

    • xpending(key: RedisKey, group: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    xpending

    • xpending(key: RedisKey, group: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    • Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.

      • group: stream
      • complexity: O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xrange

    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • +

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xrange

    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>

    • Return a range of elements in a stream, with IDs matching the specified IDs interval

      • group: stream
      • complexity: O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrangeBuffer

    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xread

    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • +

      Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrangeBuffer

    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xread

    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.

      • group: stream
      • complexity: For each stream mentioned: O(N) with N being the number of elements being returned, it means that XREAD-ing with a fixed COUNT is O(1). Note that when the BLOCK option is used, XADD will pay O(M) time in order to serve the M clients blocked on the stream getting new data.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    xreadBuffer

    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    xreadgroup

    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • +

      Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    xreadBuffer

    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    xreadgroup

    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>

    • Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.

      • group: stream
      • complexity: For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    xrevrange

    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • +

      Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    xrevrange

    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>

    • Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE

      • group: stream
      • complexity: O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrevrangeBuffer

    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xsetid

    • xsetid(key: RedisKey, lastId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrevrangeBuffer

    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xsetid

    • xsetid(key: RedisKey, lastId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • An internal command for replicating stream values

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xtrim

    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xtrim

    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>

    • Trims the stream to (approximately if '~' is passed) a certain size

      • group: stream
      • complexity: O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zadd

    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zadd

    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>

    • Add one or more members to a sorted set, or update its score if it already exists

      • group: sorted-set
      • complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
      • since: 1.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    zaddBuffer

    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    zcard

    • zcard(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    zaddBuffer

    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    zcard

    • zcard(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the number of members in a sorted set

      • group: sorted-set
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    zcount

    • zcount(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>

    zcount

    • zcount(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>

    • Count the members in a sorted set with scores within the given values

      • group: sorted-set
      • complexity: O(log(N)) with N being the number of elements in the sorted set.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zdiff

    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zdiff

    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>

    • Subtract multiple sorted sets

      • group: sorted-set
      • complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zdiffBuffer

    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zdiffstore

    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zdiffBuffer

    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zdiffstore

    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>

    • Subtract multiple sorted sets and store the resulting sorted set in a new key

      • group: sorted-set
      • complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    zincrby

    • zincrby(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<string>): Promise<string>

    zincrby

    • zincrby(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<string>): Promise<string>

    • Increment the score of a member in a sorted set

      • group: sorted-set
      • complexity: O(log(N)) where N is the number of elements in the sorted set.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zincrbyBuffer

    • zincrbyBuffer(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zinter

    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zincrbyBuffer

    • zincrbyBuffer(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zinter

    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>

    • Intersect multiple sorted sets

      • group: sorted-set
      • complexity: O(NK)+O(Mlog(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zinterBuffer

    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zintercard

    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zinterBuffer

    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zintercard

    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>

    • Intersect multiple sorted sets and return the cardinality of the result

      • group: sorted-set
      • complexity: O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    zinterstore

    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    zinterstore

    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>

    • Intersect multiple sorted sets and store the resulting sorted set in a new key

      • group: sorted-set
      • complexity: O(NK)+O(Mlog(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    zlexcount

    • zlexcount(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    zlexcount

    • zlexcount(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Count the number of members in a sorted set between a given lexicographical range

      • group: sorted-set
      • complexity: O(log(N)) with N being the number of elements in the sorted set.
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zmpop

    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zmpop

    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>

    • Remove and return members with scores in a sorted set

      • group: sorted-set
      • complexity: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    zmscore

    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    zmscore

    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>

    • Get the score associated with the given members in a sorted set

      • group: sorted-set
      • complexity: O(N) where N is the number of members being requested.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    zmscoreBuffer

    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    zpopmax

    • zpopmax(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmax(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    zmscoreBuffer

    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    zpopmax

    • zpopmax(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmax(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and return members with the highest scores in a sorted set

      • group: sorted-set
      • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zpopmaxBuffer

    • zpopmaxBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopmaxBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zpopmin

    • zpopmin(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmin(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    zpopmaxBuffer

    • zpopmaxBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopmaxBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zpopmin

    • zpopmin(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmin(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and return members with the lowest scores in a sorted set

      • group: sorted-set
      • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zpopminBuffer

    • zpopminBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopminBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zrandmember

    • zrandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • zrandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrandmember(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    zpopminBuffer

    • zpopminBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopminBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zrandmember

    • zrandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • zrandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrandmember(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    • Get one or multiple random elements from a sorted set

      • group: sorted-set
      • complexity: O(N) where N is the number of elements returned
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrandmemberBuffer

    • zrandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • zrandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrandmemberBuffer(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrange

    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    zrandmemberBuffer

    • zrandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • zrandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrandmemberBuffer(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrange

    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangeBuffer

    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebylex

    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangeBuffer

    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebylex

    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by lexicographical range

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebylexBuffer

    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebyscore

    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebylexBuffer

    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebyscore

    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by score

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 1.0.5
      -

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebyscoreBuffer

    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangestore

    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebyscoreBuffer

    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangestore

    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>

    • Store a range of members from sorted set into another key

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements stored into the destination key.
      • since: 6.2.0
      -

      Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrank

    • zrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrank

    • zrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Determine the index of a member in a sorted set

      • group: sorted-set
      • complexity: O(log(N))
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrem

    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    zrem

    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    • Remove one or more members from a sorted set

      • group: sorted-set
      • complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
      • since: 1.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    zremrangebylex

    • zremrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    zremrangebylex

    • zremrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Remove all members in a sorted set between the given lexicographical range

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyrank

    • zremrangebyrank(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyrank

    • zremrangebyrank(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<number>): Promise<number>

    • Remove all members in a sorted set within the given indexes

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyscore

    • zremrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyscore

    • zremrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>

    • Remove all members in a sorted set within the given scores

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrevrange

    • zrevrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrange(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrevrange

    • zrevrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrange(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by index, with scores ordered from high to low

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangeBuffer

    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebylex

    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangeBuffer

    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebylex

    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebylexBuffer

    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebyscore

    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebylexBuffer

    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebyscore

    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by score, with scores ordered from high to low

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebyscoreBuffer

    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrank

    • zrevrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebyscoreBuffer

    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrank

    • zrevrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Determine the index of a member in a sorted set, with scores ordered from high to low

      • group: sorted-set
      • complexity: O(log(N))
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zscan

    • zscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • +

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zscan

    • zscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate sorted sets elements and associated scores

      • group: sorted-set
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
      • since: 2.8.0
      -

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    zscanBuffer

    • zscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    zscanBufferStream

    • zscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscanStream

    • zscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscore

    • zscore(key: RedisKey, member: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    zscanBuffer

    • zscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    zscanBufferStream

    • zscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscanStream

    • zscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscore

    • zscore(key: RedisKey, member: string | number | Buffer, callback?: Callback<string>): Promise<string>

    • Get the score associated with the given member in a sorted set

      • group: sorted-set
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zscoreBuffer

    • zscoreBuffer(key: RedisKey, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zunion

    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zscoreBuffer

    • zscoreBuffer(key: RedisKey, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zunion

    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>

    • Add multiple sorted sets

      • group: sorted-set
      • complexity: O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zunionBuffer

    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zunionstore

    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zunionBuffer

    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zunionstore

    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>

    • Add multiple sorted sets and store the resulting sorted set in a new key

      • group: sorted-set
      • complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    Generated using TypeDoc

    \ No newline at end of file +

    Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

  • Parameters

    Returns Promise<number>

    • Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/classes/Redis.html b/docs/classes/Redis.html index 571c494c..b64acf81 100644 --- a/docs/classes/Redis.html +++ b/docs/classes/Redis.html @@ -3,1387 +3,1387 @@ Use it to connect to a standalone Redis server or Sentinels.

    const redis = new Redis(); // Default port is 6379
    async function main() {
      redis.set("foo", "bar");
      redis.get("foo", (err, result) => {
        // `result` should be "bar"
        console.log(err, result);
      });
      // Or use Promise
      const result = await redis.get("foo");
    }
    -

    Hierarchy

    Index

    Constructors

    Properties

    Accessors

    Methods

    Constructors

    constructor

    Properties

    options

    options: RedisOptions

    status

    status: RedisStatus = "wait"

    Static Cluster

    Cluster: typeof Cluster = Cluster

    Static Command

    Command: typeof default = Command

    Accessors

    autoPipelineQueueSize

    mode

    Hierarchy

    Index

    Constructors

    Properties

    Accessors

    Methods

    Constructors

    constructor

    Properties

    options

    options: RedisOptions

    status

    status: RedisStatus = "wait"

    Static Cluster

    Cluster: typeof Cluster = Cluster

    Static Command

    Command: typeof default = Command

    Accessors

    autoPipelineQueueSize

    • get autoPipelineQueueSize(): number

    mode

    • get mode(): "monitor" | "normal" | "subscriber"

    • Mode of the connection.

      One of "normal", "subscriber", or "monitor". When the connection is not in "normal" mode, certain commands are not allowed.

      -

      Returns "monitor" | "normal" | "subscriber"

    Methods

    acl

    • acl(subcommand: "CAT", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "CAT", categoryname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]): Promise<number>
    • acl(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<string>): Promise<string>
    • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<string>
    • acl(subcommand: "GENPASS", callback?: Callback<string>): Promise<string>
    • acl(subcommand: "GENPASS", bits: string | number, callback?: Callback<string>): Promise<string>
    • acl(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • acl(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "LIST", callback?: Callback<string[]>): Promise<string[]>
    • acl(subcommand: "LOAD", callback?: Callback<"OK">): Promise<"OK">
    • acl(subcommand: "LOG", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "LOG", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "LOG", reset: "RESET", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "SAVE", callback?: Callback<"OK">): Promise<"OK">
    • acl(subcommand: "SETUSER", username: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
    • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]): Promise<"OK">
    • acl(subcommand: "USERS", callback?: Callback<string[]>): Promise<string[]>
    • acl(subcommand: "WHOAMI", callback?: Callback<string>): Promise<string>

    Methods

    acl

    • acl(subcommand: "CAT", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "CAT", categoryname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]): Promise<number>
    • acl(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<string>): Promise<string>
    • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<string>
    • acl(subcommand: "GENPASS", callback?: Callback<string>): Promise<string>
    • acl(subcommand: "GENPASS", bits: string | number, callback?: Callback<string>): Promise<string>
    • acl(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • acl(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "LIST", callback?: Callback<string[]>): Promise<string[]>
    • acl(subcommand: "LOAD", callback?: Callback<"OK">): Promise<"OK">
    • acl(subcommand: "LOG", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "LOG", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "LOG", reset: "RESET", callback?: Callback<unknown>): Promise<unknown>
    • acl(subcommand: "SAVE", callback?: Callback<"OK">): Promise<"OK">
    • acl(subcommand: "SETUSER", username: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
    • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]): Promise<"OK">
    • acl(subcommand: "USERS", callback?: Callback<string[]>): Promise<string[]>
    • acl(subcommand: "WHOAMI", callback?: Callback<string>): Promise<string>

    • List the ACL categories or the commands inside a category

      • group: server
      • complexity: O(1) since the categories and commands are a fixed set.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "CAT"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CAT"
      • categoryname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CAT"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CAT"
      • categoryname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Remove the specified ACL users and the associated rules

      • group: server
      • complexity: O(1) amortized time considering the typical user.
      • since: 6.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]

      Returns Promise<number>

    • +

      Parameters

      • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]

      Returns Promise<number>

    • Returns whether the user can execute the given command without executing the command.

      • group: server
      • complexity: O(1).
      • since: 7.0.0
      -

      Parameters

      • subcommand: "DRYRUN"
      • username: string | Buffer
      • command: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DRYRUN"
      • username: string | Buffer
      • command: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<string>

    • Generate a pseudorandom secure password to use for ACL users

      • group: server
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • subcommand: "GENPASS"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "GENPASS"
      • bits: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "GENPASS"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "GENPASS"
      • bits: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Get the rules for a specific ACL user

      • group: server
      • complexity: O(N). Where N is the number of password, command and pattern rules that the user has.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "GETUSER"
      • username: string | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • +

      Parameters

      • subcommand: "GETUSER"
      • username: string | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List the current ACL rules in ACL config file format

      • group: server
      • complexity: O(N). Where N is the number of configured users.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Reload the ACLs from the configured ACL file

      • group: server
      • complexity: O(N). Where N is the number of configured users.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "LOAD"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "LOAD"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • List latest events denied because of ACLs in place

      • group: server
      • complexity: O(N) with N being the number of entries shown.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "LOG"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LOG"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LOG"
      • reset: "RESET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LOG"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LOG"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LOG"
      • reset: "RESET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Save the current ACL rules in the configured ACL file

      • group: server
      • complexity: O(N). Where N is the number of configured users.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "SAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "SAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Modify or create the rules for a specific ACL user

      • group: server
      • complexity: O(N). Where N is the number of rules provided.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "SETUSER"
      • username: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "SETUSER"
      • username: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]

      Returns Promise<"OK">

    • List the username of all the configured ACL rules

      • group: server
      • complexity: O(N). Where N is the number of configured users.
      • since: 6.0.0
      -

      Parameters

      • subcommand: "USERS"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • +

      Parameters

      • subcommand: "USERS"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Return the name of the user associated to the current connection

      • group: server
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • subcommand: "WHOAMI"
      • Optional callback: Callback<string>

      Returns Promise<string>

    aclBuffer

    • aclBuffer(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<Buffer>
    • aclBuffer(subcommand: "GENPASS", callback?: Callback<Buffer>): Promise<Buffer>
    • aclBuffer(subcommand: "GENPASS", bits: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • aclBuffer(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • aclBuffer(subcommand: "LIST", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • aclBuffer(subcommand: "USERS", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • aclBuffer(subcommand: "WHOAMI", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "DRYRUN"
      • username: string | Buffer
      • command: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "GENPASS"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "GENPASS"
      • bits: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "GETUSER"
      • username: string | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • subcommand: "USERS"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • subcommand: "WHOAMI"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    addBuiltinCommand

    • addBuiltinCommand(commandName: string): void
    • +

      Parameters

      • subcommand: "WHOAMI"
      • Optional callback: Callback<string>

      Returns Promise<string>

    aclBuffer

    • aclBuffer(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • aclBuffer(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<Buffer>
    • aclBuffer(subcommand: "GENPASS", callback?: Callback<Buffer>): Promise<Buffer>
    • aclBuffer(subcommand: "GENPASS", bits: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • aclBuffer(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • aclBuffer(subcommand: "LIST", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • aclBuffer(subcommand: "USERS", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • aclBuffer(subcommand: "WHOAMI", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "DRYRUN"
      • username: string | Buffer
      • command: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "GENPASS"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "GENPASS"
      • bits: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "GETUSER"
      • username: string | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • subcommand: "USERS"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • subcommand: "WHOAMI"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    addBuiltinCommand

    • addBuiltinCommand(commandName: string): void

    • Create add builtin command

      -

      Parameters

      • commandName: string

      Returns void

    append

    • append(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    append

    • append(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Append a value to a key

      • group: string
      • complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    asking

    • asking(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    asking

    • asking(callback?: Callback<"OK">): Promise<"OK">

    • Sent by cluster clients after an -ASK redirect

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    auth

    • auth(password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • auth(username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">

    auth

    • auth(password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • auth(username: string | Buffer, password: string | Buffer, callback?: Callback<"OK">): Promise<"OK">

    • Authenticate to the server

      • group: connection
      • complexity: O(N) where N is the number of passwords defined for the user
      • since: 1.0.0
      -

      Parameters

      • password: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • username: string | Buffer
      • password: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    bgrewriteaof

    • bgrewriteaof(callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • password: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • username: string | Buffer
      • password: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    bgrewriteaof

    • bgrewriteaof(callback?: Callback<string>): Promise<string>

    • Asynchronously rewrite the append-only file

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    bgrewriteaofBuffer

    • bgrewriteaofBuffer(callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    bgsave

    • bgsave(callback?: Callback<"OK">): Promise<"OK">
    • bgsave(schedule: "SCHEDULE", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    bgrewriteaofBuffer

    • bgrewriteaofBuffer(callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    bgsave

    • bgsave(callback?: Callback<"OK">): Promise<"OK">
    • bgsave(schedule: "SCHEDULE", callback?: Callback<"OK">): Promise<"OK">

    • Asynchronously save the dataset to disk

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • schedule: "SCHEDULE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    bitcount

    • bitcount(key: RedisKey, callback?: Callback<number>): Promise<number>
    • bitcount(key: RedisKey, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
    • bitcount(key: RedisKey, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
    • bitcount(key: RedisKey, start: string | number, end: string | number, bit: "BIT", callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • schedule: "SCHEDULE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    bitcount

    • bitcount(key: RedisKey, callback?: Callback<number>): Promise<number>
    • bitcount(key: RedisKey, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
    • bitcount(key: RedisKey, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
    • bitcount(key: RedisKey, start: string | number, end: string | number, bit: "BIT", callback?: Callback<number>): Promise<number>

    • Count set bits in a string

      • group: bitmap
      • complexity: O(N)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • byte: "BYTE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • bit: "BIT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    bitfield

    • bitfield(key: RedisKey, encodingOffsetToken: "GET", encoding: string | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • byte: "BYTE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • bit: "BIT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    bitfield

    • bitfield(key: RedisKey, encodingOffsetToken: "GET", encoding: string | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", wrap: "WRAP", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", sat: "SAT", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetValueToken: "SET", encoding: string | Buffer, offset: string | number, value: string | number, callback?: Callback<unknown>): Promise<unknown>
    • bitfield(key: RedisKey, overflow: "OVERFLOW", fail: "FAIL", encodingOffsetIncrementToken: "INCRBY", encoding: string | Buffer, offset: string | number, increment: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Perform arbitrary bitfield integer operations on strings

      • group: bitmap
      • complexity: O(1) for each subcommand specified
      • since: 3.2.0
      -

      Parameters

      • key: RedisKey
      • encodingOffsetToken: "GET"
      • encoding: string | Buffer
      • offset: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • wrap: "WRAP"
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • wrap: "WRAP"
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • sat: "SAT"
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • sat: "SAT"
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • fail: "FAIL"
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • fail: "FAIL"
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    bitfield_ro

    • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]): Promise<unknown[]>
    • +

      Parameters

      • key: RedisKey
      • encodingOffsetToken: "GET"
      • encoding: string | Buffer
      • offset: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • wrap: "WRAP"
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • wrap: "WRAP"
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • sat: "SAT"
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • sat: "SAT"
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • fail: "FAIL"
      • encodingOffsetValueToken: "SET"
      • encoding: string | Buffer
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • overflow: "OVERFLOW"
      • fail: "FAIL"
      • encodingOffsetIncrementToken: "INCRBY"
      • encoding: string | Buffer
      • offset: string | number
      • increment: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    bitfield_ro

    • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • bitfield_ro(...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]): Promise<unknown[]>

    • Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD

      • group: bitmap
      • complexity: O(1) for each subcommand specified
      • since: 6.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]

      Returns Promise<unknown[]>

    bitop

    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]

      Returns Promise<unknown[]>

    bitop

    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • bitop(...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[]]): Promise<number>

    • Perform bitwise operations between strings

      • group: bitmap
      • complexity: O(N)
      • since: 2.6.0
      -

      Parameters

      • Rest ...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    bitpos

    • bitpos(key: RedisKey, bit: string | number, callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, bit1: "BIT", callback?: Callback<number>): Promise<number>

    bitpos

    • bitpos(key: RedisKey, bit: string | number, callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, byte: "BYTE", callback?: Callback<number>): Promise<number>
    • bitpos(key: RedisKey, bit: string | number, start: string | number, end: string | number, bit1: "BIT", callback?: Callback<number>): Promise<number>

    • Find first bit set or clear in a string

      • group: bitmap
      • complexity: O(N)
      • since: 2.8.7
      -

      Parameters

      • key: RedisKey
      • bit: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • end: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • end: string | number
      • byte: "BYTE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • end: string | number
      • bit1: "BIT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    blmove

    • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • bit: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • end: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • end: string | number
      • byte: "BYTE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • bit: string | number
      • start: string | number
      • end: string | number
      • bit1: "BIT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    blmove

    • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • blmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<string>): Promise<string>
    • blmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<string>): Promise<string>

    • Pop an element from a list, push it to another list and return it; or block until one is available

      • group: list
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • left1: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • right: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • left: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • right1: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    blmoveBuffer

    • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • left1: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • right: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • left: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • right1: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    blmpop

    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • +

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • left1: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • right: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • left: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • right1: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    blmoveBuffer

    • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • blmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • blmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • left1: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • right: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • left: "LEFT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • right1: "RIGHT"
      • timeout: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    blmpop

    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • blmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>

    • Pop elements from a list, or block until one is available

      • group: list
      • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    blmpopBuffer

    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    blpop

    • blpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • blpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • blpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
    • blpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
    • +

      Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    blmpopBuffer

    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • blmpopBuffer(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    blpop

    • blpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • blpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • blpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
    • blpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>

    • Remove and get the first element in a list, or block until one is available

      • group: list
      • complexity: O(N) where N is the number of provided keys.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    blpopBuffer

    • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
    • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    brpop

    • brpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • brpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • brpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
    • brpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
    • +

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    blpopBuffer

    • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • blpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
    • blpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    brpop

    • brpop(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • brpop(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]): Promise<[string, string]>
    • brpop(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[string, string]>
    • brpop(...args: [keys: RedisKey[], timeout: string | number]): Promise<[string, string]>

    • Remove and get the last element in a list, or block until one is available

      • group: list
      • complexity: O(N) where N is the number of provided keys.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    brpopBuffer

    • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
    • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    brpoplpush

    • brpoplpush(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[string, string]>]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[string, string]>

    brpopBuffer

    • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]): Promise<[Buffer, Buffer]>
    • brpopBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>
    • brpopBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[Buffer, Buffer]>]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[Buffer, Buffer]>

    brpoplpush

    • brpoplpush(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<string>): Promise<string>

    • Pop an element from a list, push it to another list and return it; or block until one is available

      • group: list
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • timeout: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    brpoplpushBuffer

    • brpoplpushBuffer(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    bzmpop

    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>

    brpoplpushBuffer

    • brpoplpushBuffer(source: RedisKey, destination: RedisKey, timeout: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    bzmpop

    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • bzmpop(...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>

    • Remove and return members with scores in a sorted set or block until one is available

      • group: sorted-set
      • complexity: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    bzpopmax

    • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmax(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
    • bzpopmax(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
    • +

      Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    bzpopmax

    • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmax(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmax(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
    • bzpopmax(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>

    • Remove and return the member with the highest score from one or more sorted sets, or block until one is available

      • group: sorted-set
      • complexity: O(log(N)) with N being the number of elements in the sorted set.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    bzpopmaxBuffer

    • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    bzpopmin

    • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmin(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
    • bzpopmin(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
    • +

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    bzpopmaxBuffer

    • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopmaxBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopmaxBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    bzpopmin

    • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmin(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]): Promise<[key: string, member: string, score: string]>
    • bzpopmin(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>
    • bzpopmin(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: string, member: string, score: string]>

    • Remove and return the member with the lowest score from one or more sorted sets, or block until one is available

      • group: sorted-set
      • complexity: O(log(N)) with N being the number of elements in the sorted set.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    bzpopminBuffer

    • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    call

    • call(command: string, callback?: Callback<unknown>): Promise<unknown>
    • call(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
    • call(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • call(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: string, member: string, score: string]>]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: string, member: string, score: string]>

    bzpopminBuffer

    • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopminBuffer(...args: [...keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>
    • bzpopminBuffer(...args: [keys: RedisKey[], timeout: string | number]): Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [...keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], timeout: string | number]

      Returns Promise<[key: Buffer, member: Buffer, score: Buffer]>

    call

    • call(command: string, callback?: Callback<unknown>): Promise<unknown>
    • call(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
    • call(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • call(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

    • Call arbitrary commands.

      redis.call('set', 'foo', 'bar') is the same as redis.set('foo', 'bar'), so the only case you need to use this method is when the command is not supported by ioredis.

      redis.call('set', 'foo', 'bar');
      redis.call('get', 'foo', (err, value) => {
        // value === 'bar'
      });
      -

      Parameters

      • command: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • command: string
      • args: (string | number | Buffer)[]
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    callBuffer

    • callBuffer(command: string, callback?: Callback<unknown>): Promise<unknown>
    • callBuffer(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
    • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

    • Parameters

      • command: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • command: string
      • args: (string | number | Buffer)[]
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    client

    • client(subcommand: "CACHING", yes: "YES", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "CACHING", no: "NO", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "GETNAME", callback?: Callback<string>): Promise<string>
    • client(subcommand: "GETREDIR", callback?: Callback<number>): Promise<number>
    • client(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "ID", callback?: Callback<number>): Promise<number>
    • client(subcommand: "INFO", callback?: Callback<string>): Promise<string>
    • client(...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "KILL", ...args: RedisValue[]]): Promise<unknown>
    • client(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", normal: "NORMAL", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", master: "MASTER", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", replica: "REPLICA", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "NO-EVICT", on: "ON", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "NO-EVICT", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "PAUSE", timeout: string | number, callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "PAUSE", timeout: string | number, write: "WRITE", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "PAUSE", timeout: string | number, all: "ALL", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "REPLY", on: "ON", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "REPLY", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "REPLY", skip: "SKIP", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "SETNAME", connectionName: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • client(...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "TRACKING", ...args: RedisValue[]]): Promise<unknown>
    • client(subcommand: "TRACKINGINFO", callback?: Callback<string>): Promise<string>
    • client(subcommand: "UNBLOCK", clientId: string | number, callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "UNBLOCK", clientId: string | number, timeout: "TIMEOUT", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "UNBLOCK", clientId: string | number, error: "ERROR", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "UNPAUSE", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • command: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • command: string
      • args: (string | number | Buffer)[]
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    callBuffer

    • callBuffer(command: string, callback?: Callback<unknown>): Promise<unknown>
    • callBuffer(command: string, args: (string | number | Buffer)[], callback?: Callback<unknown>): Promise<unknown>
    • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • callBuffer(...args: [command: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

    • Parameters

      • command: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • command: string
      • args: (string | number | Buffer)[]
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [command: string, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    client

    • client(subcommand: "CACHING", yes: "YES", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "CACHING", no: "NO", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "GETNAME", callback?: Callback<string>): Promise<string>
    • client(subcommand: "GETREDIR", callback?: Callback<number>): Promise<number>
    • client(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "ID", callback?: Callback<number>): Promise<number>
    • client(subcommand: "INFO", callback?: Callback<string>): Promise<string>
    • client(...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "KILL", ...args: RedisValue[]]): Promise<unknown>
    • client(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", normal: "NORMAL", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", master: "MASTER", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", replica: "REPLICA", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", callback?: Callback<unknown>): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]): Promise<unknown>
    • client(subcommand: "NO-EVICT", on: "ON", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "NO-EVICT", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "PAUSE", timeout: string | number, callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "PAUSE", timeout: string | number, write: "WRITE", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "PAUSE", timeout: string | number, all: "ALL", callback?: Callback<"OK">): Promise<"OK">
    • client(subcommand: "REPLY", on: "ON", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "REPLY", off: "OFF", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "REPLY", skip: "SKIP", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "SETNAME", connectionName: string | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • client(...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • client(...args: [subcommand: "TRACKING", ...args: RedisValue[]]): Promise<unknown>
    • client(subcommand: "TRACKINGINFO", callback?: Callback<string>): Promise<string>
    • client(subcommand: "UNBLOCK", clientId: string | number, callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "UNBLOCK", clientId: string | number, timeout: "TIMEOUT", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "UNBLOCK", clientId: string | number, error: "ERROR", callback?: Callback<unknown>): Promise<unknown>
    • client(subcommand: "UNPAUSE", callback?: Callback<"OK">): Promise<"OK">

    • Instruct the server about tracking or not keys in the next request

      • group: connection
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • subcommand: "CACHING"
      • yes: "YES"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "CACHING"
      • no: "NO"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "CACHING"
      • yes: "YES"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "CACHING"
      • no: "NO"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Get the current connection name

      • group: connection
      • complexity: O(1)
      • since: 2.6.9
      -

      Parameters

      • subcommand: "GETNAME"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "GETNAME"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Get tracking notifications redirection client ID if any

      • group: connection
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • subcommand: "GETREDIR"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • +

      Parameters

      • subcommand: "GETREDIR"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Show helpful text about the different subcommands

      • group: connection
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Returns the client ID for the current connection

      • group: connection
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "ID"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • +

      Parameters

      • subcommand: "ID"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Returns information about the current client connection.

      • group: connection
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Kill the connection of a client

      • group: connection
      • complexity: O(N) where N is the number of client connections
      • since: 2.4.0
      -

      Parameters

      • Rest ...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "KILL", ...args: RedisValue[]]

      Returns Promise<unknown>

    • +

      Parameters

      • Rest ...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "KILL", ...args: RedisValue[]]

      Returns Promise<unknown>

    • Get the list of client connections

      • group: connection
      • complexity: O(N) where N is the number of client connections
      • since: 2.4.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • normal: "NORMAL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • master: "MASTER"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • replica: "REPLICA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • pubsub: "PUBSUB"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • normal: "NORMAL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • master: "MASTER"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • replica: "REPLICA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Parameters

      • subcommand: "LIST"
      • type: "TYPE"
      • pubsub: "PUBSUB"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]

      Returns Promise<unknown>

    • Set client eviction mode for the current connection

      • group: connection
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "NO-EVICT"
      • on: "ON"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "NO-EVICT"
      • off: "OFF"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "NO-EVICT"
      • on: "ON"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "NO-EVICT"
      • off: "OFF"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Stop processing commands from clients for some time

      • group: connection
      • complexity: O(1)
      • since: 2.9.50
      -

      Parameters

      • subcommand: "PAUSE"
      • timeout: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "PAUSE"
      • timeout: string | number
      • write: "WRITE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "PAUSE"
      • timeout: string | number
      • all: "ALL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "PAUSE"
      • timeout: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "PAUSE"
      • timeout: string | number
      • write: "WRITE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "PAUSE"
      • timeout: string | number
      • all: "ALL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Instruct the server whether to reply to commands

      • group: connection
      • complexity: O(1)
      • since: 3.2.0
      -

      Parameters

      • subcommand: "REPLY"
      • on: "ON"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "REPLY"
      • off: "OFF"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "REPLY"
      • skip: "SKIP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "REPLY"
      • on: "ON"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "REPLY"
      • off: "OFF"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "REPLY"
      • skip: "SKIP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Set the current connection name

      • group: connection
      • complexity: O(1)
      • since: 2.6.9
      -

      Parameters

      • subcommand: "SETNAME"
      • connectionName: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "SETNAME"
      • connectionName: string | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Enable or disable server assisted client side caching support

      • group: connection
      • complexity: O(1). Some options may introduce additional complexity.
      • since: 6.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[]]

      Returns Promise<unknown>

    • +

      Parameters

      • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "TRACKING", ...args: RedisValue[]]

      Returns Promise<unknown>

    • Return information about server assisted client side caching for the current connection

      • group: connection
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "TRACKINGINFO"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "TRACKINGINFO"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Unblock a client blocked in a blocking command from a different connection

      • group: connection
      • complexity: O(log N) where N is the number of client connections
      • since: 5.0.0
      -

      Parameters

      • subcommand: "UNBLOCK"
      • clientId: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "UNBLOCK"
      • clientId: string | number
      • timeout: "TIMEOUT"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "UNBLOCK"
      • clientId: string | number
      • error: "ERROR"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "UNBLOCK"
      • clientId: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "UNBLOCK"
      • clientId: string | number
      • timeout: "TIMEOUT"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "UNBLOCK"
      • clientId: string | number
      • error: "ERROR"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Resume processing of clients that were paused

      • group: connection
      • complexity: O(N) Where N is the number of paused clients
      • since: 6.2.0
      -

      Parameters

      • subcommand: "UNPAUSE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    clientBuffer

    • clientBuffer(subcommand: "GETNAME", callback?: Callback<Buffer>): Promise<Buffer>
    • clientBuffer(subcommand: "INFO", callback?: Callback<Buffer>): Promise<Buffer>
    • clientBuffer(subcommand: "TRACKINGINFO", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "GETNAME"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "TRACKINGINFO"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    cluster

    • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(subcommand: "BUMPEPOCH", callback?: Callback<"BUMPED" | "STILL">): Promise<"BUMPED" | "STILL">
    • cluster(subcommand: "COUNT-FAILURE-REPORTS", nodeId: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • cluster(subcommand: "COUNTKEYSINSLOT", slot: string | number, callback?: Callback<number>): Promise<number>
    • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(subcommand: "FAILOVER", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "FAILOVER", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "FAILOVER", takeover: "TAKEOVER", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "FLUSHSLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(subcommand: "FORGET", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "GETKEYSINSLOT", slot: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • cluster(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "INFO", callback?: Callback<string>): Promise<string>
    • cluster(subcommand: "KEYSLOT", key: string | Buffer, callback?: Callback<number>): Promise<number>
    • cluster(subcommand: "LINKS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • cluster(subcommand: "MEET", ip: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "MYID", callback?: Callback<string>): Promise<string>
    • cluster(subcommand: "NODES", callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "REPLICAS", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "REPLICATE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "RESET", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "RESET", hard: "HARD", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "RESET", soft: "SOFT", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SAVECONFIG", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SET-CONFIG-EPOCH", configEpoch: string | number, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "IMPORTING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "MIGRATING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "NODE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, stable: "STABLE", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SHARDS", callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "SLAVES", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "SLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • +

      Parameters

      • subcommand: "UNPAUSE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    clientBuffer

    • clientBuffer(subcommand: "GETNAME", callback?: Callback<Buffer>): Promise<Buffer>
    • clientBuffer(subcommand: "INFO", callback?: Callback<Buffer>): Promise<Buffer>
    • clientBuffer(subcommand: "TRACKINGINFO", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "GETNAME"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "TRACKINGINFO"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    cluster

    • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(subcommand: "BUMPEPOCH", callback?: Callback<"BUMPED" | "STILL">): Promise<"BUMPED" | "STILL">
    • cluster(subcommand: "COUNT-FAILURE-REPORTS", nodeId: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • cluster(subcommand: "COUNTKEYSINSLOT", slot: string | number, callback?: Callback<number>): Promise<number>
    • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTS", slots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(subcommand: "FAILOVER", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "FAILOVER", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "FAILOVER", takeover: "TAKEOVER", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "FLUSHSLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>
    • cluster(subcommand: "FORGET", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "GETKEYSINSLOT", slot: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • cluster(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "INFO", callback?: Callback<string>): Promise<string>
    • cluster(subcommand: "KEYSLOT", key: string | Buffer, callback?: Callback<number>): Promise<number>
    • cluster(subcommand: "LINKS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • cluster(subcommand: "MEET", ip: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "MYID", callback?: Callback<string>): Promise<string>
    • cluster(subcommand: "NODES", callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "REPLICAS", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "REPLICATE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "RESET", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "RESET", hard: "HARD", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "RESET", soft: "SOFT", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SAVECONFIG", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SET-CONFIG-EPOCH", configEpoch: string | number, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "IMPORTING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "MIGRATING", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, nodeIdToken: "NODE", nodeId: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SETSLOT", slot: string | number, stable: "STABLE", callback?: Callback<"OK">): Promise<"OK">
    • cluster(subcommand: "SHARDS", callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "SLAVES", nodeId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • cluster(subcommand: "SLOTS", callback?: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Assign new hash slots to receiving node

      • group: cluster
      • complexity: O(N) where N is the total number of hash slot arguments
      • since: 3.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • +

      Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Assign new hash slots to receiving node

      • group: cluster
      • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • +

      Parameters

      • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Advance the cluster config epoch

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "BUMPEPOCH"
      • Optional callback: Callback<"BUMPED" | "STILL">

      Returns Promise<"BUMPED" | "STILL">

    • +

      Parameters

      • subcommand: "BUMPEPOCH"
      • Optional callback: Callback<"BUMPED" | "STILL">

      Returns Promise<"BUMPED" | "STILL">

    • Return the number of failure reports active for a given node

      • group: cluster
      • complexity: O(N) where N is the number of failure reports
      • since: 3.0.0
      -

      Parameters

      • subcommand: "COUNT-FAILURE-REPORTS"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • +

      Parameters

      • subcommand: "COUNT-FAILURE-REPORTS"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Return the number of local keys in the specified hash slot

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "COUNTKEYSINSLOT"
      • slot: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • +

      Parameters

      • subcommand: "COUNTKEYSINSLOT"
      • slot: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Set hash slots as unbound in receiving node

      • group: cluster
      • complexity: O(N) where N is the total number of hash slot arguments
      • since: 3.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • +

      Parameters

      • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTS", slots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Set hash slots as unbound in receiving node

      • group: cluster
      • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • +

      Parameters

      • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Parameters

      • Rest ...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Forces a replica to perform a manual failover of its master.

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "FAILOVER"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "FAILOVER"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "FAILOVER"
      • takeover: "TAKEOVER"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "FAILOVER"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "FAILOVER"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "FAILOVER"
      • takeover: "TAKEOVER"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Delete a node's own slots information

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "FLUSHSLOTS"
      • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • +

      Parameters

      • subcommand: "FLUSHSLOTS"
      • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    • Remove a node from the nodes table

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "FORGET"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "FORGET"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Return local key names in the specified hash slot

      • group: cluster
      • complexity: O(log(N)) where N is the number of requested keys
      • since: 3.0.0
      -

      Parameters

      • subcommand: "GETKEYSINSLOT"
      • slot: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • +

      Parameters

      • subcommand: "GETKEYSINSLOT"
      • slot: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Show helpful text about the different subcommands

      • group: cluster
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Provides info about Redis Cluster node state

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Returns the hash slot of the specified key

      • group: cluster
      • complexity: O(N) where N is the number of bytes in the key
      • since: 3.0.0
      -

      Parameters

      • subcommand: "KEYSLOT"
      • key: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • +

      Parameters

      • subcommand: "KEYSLOT"
      • key: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Returns a list of all TCP links to and from peer nodes in cluster

      • group: cluster
      • complexity: O(N) where N is the total number of Cluster nodes
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LINKS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "LINKS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Force a node cluster to handshake with another node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "MEET"
      • ip: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "MEET"
      • ip: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Return the node id

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "MYID"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "MYID"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Get Cluster config for the node

      • group: cluster
      • complexity: O(N) where N is the total number of Cluster nodes
      • since: 3.0.0
      -

      Parameters

      • subcommand: "NODES"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "NODES"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List replica nodes of the specified master node

      • group: cluster
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "REPLICAS"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "REPLICAS"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Reconfigure a node as a replica of the specified master node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "REPLICATE"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "REPLICATE"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Reset a Redis Cluster node

      • group: cluster
      • complexity: O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.
      • since: 3.0.0
      -

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "RESET"
      • hard: "HARD"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "RESET"
      • soft: "SOFT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "RESET"
      • hard: "HARD"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "RESET"
      • soft: "SOFT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Forces the node to save cluster state on disk

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "SAVECONFIG"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "SAVECONFIG"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Set the configuration epoch in a new node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "SET-CONFIG-EPOCH"
      • configEpoch: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "SET-CONFIG-EPOCH"
      • configEpoch: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Bind a hash slot to a specific node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • nodeIdToken: "IMPORTING"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • nodeIdToken: "MIGRATING"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • nodeIdToken: "NODE"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • stable: "STABLE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • nodeIdToken: "IMPORTING"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • nodeIdToken: "MIGRATING"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • nodeIdToken: "NODE"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • subcommand: "SETSLOT"
      • slot: string | number
      • stable: "STABLE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Get array of cluster slots to node mappings

      • group: cluster
      • complexity: O(N) where N is the total number of cluster nodes
      • since: 7.0.0
      -

      Parameters

      • subcommand: "SHARDS"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "SHARDS"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List replica nodes of the specified master node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • subcommand: "SLAVES"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "SLAVES"
      • nodeId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get array of Cluster slot to node mappings

      • group: cluster
      • complexity: O(N) where N is the total number of Cluster nodes
      • since: 3.0.0
      -

      Parameters

      • subcommand: "SLOTS"
      • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    command

    • command(subcommand: "COUNT", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "DOCS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
    • command(subcommand: "GETKEYS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "GETKEYSANDFLAGS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "INFO", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
    • command(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "LIST", filterby: "FILTERBY", moduleNameToken: "MODULE", moduleName: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "LIST", filterby: "FILTERBY", categoryToken: "ACLCAT", category: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "LIST", filterby: "FILTERBY", patternToken: "PATTERN", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • +

      Parameters

      • subcommand: "SLOTS"
      • Optional callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

      Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    command

    • command(subcommand: "COUNT", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "DOCS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • command(...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
    • command(subcommand: "GETKEYS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "GETKEYSANDFLAGS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "INFO", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • command(...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]): Promise<unknown[]>
    • command(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "LIST", filterby: "FILTERBY", moduleNameToken: "MODULE", moduleName: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "LIST", filterby: "FILTERBY", categoryToken: "ACLCAT", category: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • command(subcommand: "LIST", filterby: "FILTERBY", patternToken: "PATTERN", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>

    • Get total number of Redis commands

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "COUNT"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "COUNT"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get array of specific Redis command documentation

      • group: server
      • complexity: O(N) where N is the number of commands to look up
      • since: 7.0.0
      -

      Parameters

      • subcommand: "DOCS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "DOCS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • Extract keys given a full Redis command

      • group: server
      • complexity: O(N) where N is the number of arguments to the command
      • since: 2.8.13
      -

      Parameters

      • subcommand: "GETKEYS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "GETKEYS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Extract keys and access flags given a full Redis command

      • group: server
      • complexity: O(N) where N is the number of arguments to the command
      • since: 7.0.0
      -

      Parameters

      • subcommand: "GETKEYSANDFLAGS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "GETKEYSANDFLAGS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get array of specific Redis command details, or all when no argument is given.

      • group: server
      • complexity: O(N) where N is the number of commands to look up
      • since: 2.8.13
      -

      Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "INFO"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • Get an array of Redis command names

      • group: server
      • complexity: O(N) where N is the total number of Redis commands
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • filterby: "FILTERBY"
      • moduleNameToken: "MODULE"
      • moduleName: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • filterby: "FILTERBY"
      • categoryToken: "ACLCAT"
      • category: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • filterby: "FILTERBY"
      • patternToken: "PATTERN"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    config

    • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]): Promise<unknown>
    • config(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • config(subcommand: "RESETSTAT", callback?: Callback<unknown>): Promise<unknown>
    • config(subcommand: "REWRITE", callback?: Callback<unknown>): Promise<unknown>
    • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]): Promise<unknown>
    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • filterby: "FILTERBY"
      • moduleNameToken: "MODULE"
      • moduleName: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • filterby: "FILTERBY"
      • categoryToken: "ACLCAT"
      • category: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • filterby: "FILTERBY"
      • patternToken: "PATTERN"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    config

    • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • config(...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]): Promise<unknown>
    • config(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • config(subcommand: "RESETSTAT", callback?: Callback<unknown>): Promise<unknown>
    • config(subcommand: "REWRITE", callback?: Callback<unknown>): Promise<unknown>
    • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • config(...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]): Promise<unknown>

    • Get the values of configuration parameters

      • group: server
      • complexity: O(N) when N is the number of configuration parameters provided
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Reset the stats returned by INFO

      • group: server
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • subcommand: "RESETSTAT"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "RESETSTAT"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Rewrite the configuration file with the in memory configuration

      • group: server
      • complexity: O(1)
      • since: 2.8.0
      -

      Parameters

      • subcommand: "REWRITE"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "REWRITE"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Set configuration parameters to the given values

      • group: server
      • complexity: O(N) when N is the number of configuration parameters provided
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]

      Returns Promise<unknown>

    connect

    • connect(callback?: Callback<void>): Promise<void>
    • +

      Parameters

      • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]

      Returns Promise<unknown>

    connect

    • connect(callback?: Callback<void>): Promise<void>

    • Create a connection to Redis. This method will be invoked automatically when creating a new Redis instance unless lazyConnect: true is passed.

      When calling this method manually, a Promise is returned, which will be resolved when the connection status is ready.

      -

      Parameters

      • Optional callback: Callback<void>

      Returns Promise<void>

    copy

    • copy(source: RedisKey, destination: RedisKey, callback?: Callback<number>): Promise<number>
    • copy(source: RedisKey, destination: RedisKey, replace: "REPLACE", callback?: Callback<number>): Promise<number>
    • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, callback?: Callback<number>): Promise<number>
    • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, replace: "REPLACE", callback?: Callback<number>): Promise<number>

    copy

    • copy(source: RedisKey, destination: RedisKey, callback?: Callback<number>): Promise<number>
    • copy(source: RedisKey, destination: RedisKey, replace: "REPLACE", callback?: Callback<number>): Promise<number>
    • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, callback?: Callback<number>): Promise<number>
    • copy(source: RedisKey, destination: RedisKey, destinationDbToken: "DB", destinationDb: string | number, replace: "REPLACE", callback?: Callback<number>): Promise<number>

    • Copy a key

      • group: generic
      • complexity: O(N) worst case for collections, where N is the number of nested items. O(1) for string values.
      • since: 6.2.0
      -

      Parameters

      Returns Promise<number>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • replace: "REPLACE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • destinationDbToken: "DB"
      • destinationDb: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • destinationDbToken: "DB"
      • destinationDb: string | number
      • replace: "REPLACE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    createBuiltinCommand

    • createBuiltinCommand(commandName: string): { buffer: any; string: any }
    • +

      Parameters

      Returns Promise<number>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • replace: "REPLACE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • destinationDbToken: "DB"
      • destinationDb: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • destinationDbToken: "DB"
      • destinationDb: string | number
      • replace: "REPLACE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    createBuiltinCommand

    • createBuiltinCommand(commandName: string): { buffer: any; string: any }

    • Create a builtin command

      -

      Parameters

      • commandName: string

      Returns { buffer: any; string: any }

      • buffer: any
      • string: any

    dbsize

    • dbsize(callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • commandName: string

      Returns { buffer: any; string: any }

      • buffer: any
      • string: any

    dbsize

    • dbsize(callback?: Callback<number>): Promise<number>

    • Return the number of keys in the selected database

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<number>

      Returns Promise<number>

    debug

    • debug(subcommand: string, callback?: Callback<unknown>): Promise<unknown>
    • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

    debug

    • debug(subcommand: string, callback?: Callback<unknown>): Promise<unknown>
    • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • debug(...args: [subcommand: string, ...args: (string | number | Buffer)[]]): Promise<unknown>

    • A container for debugging commands

      • group: server
      • complexity: Depends on subcommand.
      • since: 1.0.0
      -

      Parameters

      • subcommand: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    decr

    • decr(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • subcommand: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: string, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    decr

    • decr(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Decrement the integer value of a key by one

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    decrby

    • decrby(key: RedisKey, decrement: string | number, callback?: Callback<number>): Promise<number>

    decrby

    • decrby(key: RedisKey, decrement: string | number, callback?: Callback<number>): Promise<number>

    • Decrement the integer value of a key by the given number

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • decrement: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    defineCommand

    • defineCommand(name: string, definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }): void
    • +

      Parameters

      • key: RedisKey
      • decrement: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    defineCommand

    • defineCommand(name: string, definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }): void

    • Define a custom command using lua script

      -

      Parameters

      • name: string
      • definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }
        • lua: string
        • Optional numberOfKeys?: number
        • Optional readOnly?: boolean

      Returns void

    del

    • del(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • del(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • del(...args: RedisKey[]): Promise<number>
    • del(...args: [keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • name: string
      • definition: { lua: string; numberOfKeys?: number; readOnly?: boolean }
        • lua: string
        • Optional numberOfKeys?: number
        • Optional readOnly?: boolean

      Returns void

    del

    • del(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • del(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • del(...args: RedisKey[]): Promise<number>
    • del(...args: [keys: RedisKey[]]): Promise<number>

    • Delete a key

      • group: generic
      • complexity: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    discard

    • discard(callback?: Callback<"OK">): Promise<"OK">

    discard

    • discard(callback?: Callback<"OK">): Promise<"OK">

    • Discard all commands issued after MULTI

      • group: transactions
      • complexity: O(N), when N is the number of queued commands
      • since: 2.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    disconnect

    • disconnect(reconnect?: boolean): void
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    disconnect

    • disconnect(reconnect?: boolean): void

    • Disconnect from Redis.

      This method closes the connection immediately, and may lose some pending replies that haven't written to client. If you want to wait for the pending replies, use Redis#quit instead.

      -

      Parameters

      • reconnect: boolean = false

      Returns void

    dump

    • dump(key: RedisKey, callback?: Callback<string>): Promise<string>

    dump

    • dump(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Return a serialized version of the value stored at the specified key.

      • group: generic
      • complexity: O(1) to access the key and additional O(NM) to serialize it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1).
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    dumpBuffer

    • dumpBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    duplicate

    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    dumpBuffer

    • dumpBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    duplicate

    • Create a new instance with the same options as the current one.

      example
      var redis = new Redis(6380);
      var anotherRedis = redis.duplicate();
      -

      Parameters

      Returns Redis

    echo

    • echo(message: string | Buffer, callback?: Callback<string>): Promise<string>

    echo

    • echo(message: string | Buffer, callback?: Callback<string>): Promise<string>

    • Echo the given string

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    echoBuffer

    • echoBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    end

    • end(): void
    • +

      Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    echoBuffer

    • echoBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    end

    • end(): void

    • Disconnect from Redis.

      -
      deprecated

      Returns void

    eval

    • eval(script: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    eval

    • eval(script: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 2.6.0
      -

      Parameters

      • script: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    eval_ro

    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • script: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    eval_ro

    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • eval_ro(...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a read-only Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha

    • evalsha(sha1: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha

    • evalsha(sha1: string | Buffer, numkeys: string | number, callback?: Callback<unknown>): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 2.6.0
      -

      Parameters

      • sha1: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha_ro

    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • sha1: string | Buffer
      • numkeys: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    evalsha_ro

    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • evalsha_ro(...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Execute a read-only Lua script server side

      • group: scripting
      • complexity: Depends on the script that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    exec

    • exec(callback?: Callback<[error: Error, result: unknown][]>): Promise<[error: Error, result: unknown][]>
    • +

      Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    exec

    • exec(callback?: Callback<[error: Error, result: unknown][]>): Promise<[error: Error, result: unknown][]>

    • Execute all commands issued after MULTI

      • group: transactions
      • complexity: Depends on commands in the transaction
      • since: 1.2.0
      -

      Parameters

      • Optional callback: Callback<[error: Error, result: unknown][]>

      Returns Promise<[error: Error, result: unknown][]>

    exists

    • exists(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: RedisKey[]): Promise<number>
    • exists(...args: [keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<[error: Error, result: unknown][]>

      Returns Promise<[error: Error, result: unknown][]>

    exists

    • exists(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • exists(...args: RedisKey[]): Promise<number>
    • exists(...args: [keys: RedisKey[]]): Promise<number>

    expire

    • expire(key: RedisKey, seconds: string | number, callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    expire

    • expire(key: RedisKey, seconds: string | number, callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expire(key: RedisKey, seconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set a key's time to live in seconds

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • seconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expireat

    • expireat(key: RedisKey, unixTimeSeconds: string | number, callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • seconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • seconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expireat

    • expireat(key: RedisKey, unixTimeSeconds: string | number, callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • expireat(key: RedisKey, unixTimeSeconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set the expiration for a key as a UNIX timestamp

      • group: generic
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expiretime

    • expiretime(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeSeconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    expiretime

    • expiretime(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the expiration Unix timestamp for a key

      • group: generic
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    failover

    • failover(callback?: Callback<"OK">): Promise<"OK">
    • failover(millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">

    failover

    • failover(callback?: Callback<"OK">): Promise<"OK">
    • failover(millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • failover(targetToken: "TO", host: string | Buffer, port: string | number, force: "FORCE", abort: "ABORT", millisecondsToken: "TIMEOUT", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Start a coordinated failover between this server and one of its replicas.

      • group: server
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    fcall

    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • targetToken: "TO"
      • host: string | Buffer
      • port: string | number
      • force: "FORCE"
      • abort: "ABORT"
      • millisecondsToken: "TIMEOUT"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    fcall

    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Invoke a function

      • group: scripting
      • complexity: Depends on the function that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    fcall_ro

    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    fcall_ro

    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • fcall_ro(...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Invoke a read-only function

      • group: scripting
      • complexity: Depends on the function that is executed.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    flushall

    • flushall(callback?: Callback<"OK">): Promise<"OK">
    • flushall(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushall(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    flushall

    • flushall(callback?: Callback<"OK">): Promise<"OK">
    • flushall(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushall(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">

    • Remove all keys from all databases

      • group: server
      • complexity: O(N) where N is the total number of keys in all databases
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    flushdb

    • flushdb(callback?: Callback<"OK">): Promise<"OK">
    • flushdb(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushdb(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    flushdb

    • flushdb(callback?: Callback<"OK">): Promise<"OK">
    • flushdb(async: "ASYNC", callback?: Callback<"OK">): Promise<"OK">
    • flushdb(sync: "SYNC", callback?: Callback<"OK">): Promise<"OK">

    • Remove all keys from the current database

      • group: server
      • complexity: O(N) where N is the number of keys in the selected database
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    function

    • function(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "DUMP", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • function(subcommand: "KILL", callback?: Callback<string>): Promise<string>
    • function(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<string>): Promise<string>
    • function(subcommand: "STATS", callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • async: "ASYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • sync: "SYNC"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    function

    • function(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "DUMP", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<string>): Promise<string>
    • function(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • function(subcommand: "KILL", callback?: Callback<string>): Promise<string>
    • function(subcommand: "LIST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LIST", libraryNamePatternToken: "LIBRARYNAME", libraryNamePattern: string | Buffer, withcode: "WITHCODE", callback?: Callback<unknown[]>): Promise<unknown[]>
    • function(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<string>): Promise<string>
    • function(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<string>): Promise<string>
    • function(subcommand: "STATS", callback?: Callback<unknown>): Promise<unknown>

    • Delete a function by name

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Dump all functions into a serialized binary payload

      • group: scripting
      • complexity: O(N) where N is the number of functions
      • since: 7.0.0
      -

      Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Deleting all functions

      • group: scripting
      • complexity: O(N) where N is the number of functions deleted
      • since: 7.0.0
      -

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Show helpful text about the different subcommands

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Kill the function currently in execution.

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • List information about all the functions

      • group: scripting
      • complexity: O(N) where N is the number of functions
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "LIST"
      • libraryNamePatternToken: "LIBRARYNAME"
      • libraryNamePattern: string | Buffer
      • withcode: "WITHCODE"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Create a function with the given arguments (name, code, description)

      • group: scripting
      • complexity: O(1) (considering compilation time is redundant)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Restore all the functions on the given payload

      • group: scripting
      • complexity: O(N) where N is the number of functions on the payload
      • since: 7.0.0
      -

      Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Return information about the function currently running (name, description, duration)

      • group: scripting
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    functionBuffer

    • functionBuffer(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "DUMP", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "KILL", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geoadd

    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    functionBuffer

    • functionBuffer(subcommand: "DELETE", libraryName: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "DUMP", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "KILL", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "LOAD", replace: "REPLACE", functionCode: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, flush: "FLUSH", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, append: "APPEND", callback?: Callback<Buffer>): Promise<Buffer>
    • functionBuffer(subcommand: "RESTORE", serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • subcommand: "DELETE"
      • libraryName: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "DUMP"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "LOAD"
      • replace: "REPLACE"
      • functionCode: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • flush: "FLUSH"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • append: "APPEND"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • subcommand: "RESTORE"
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geoadd

    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • geoadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]): Promise<number>

    • Add one or more geospatial items in the geospatial index represented using a sorted set

      • group: geo
      • complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    geodist

    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    geodist

    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<string>): Promise<string>
    • geodist(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<string>): Promise<string>

    • Returns the distance between two members of a geospatial index

      • group: geo
      • complexity: O(log(N))
      • since: 3.2.0
      -

      Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<string>

      Returns Promise<string>

    geodistBuffer

    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geohash

    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<string>

      Returns Promise<string>

    geodistBuffer

    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, m: "M", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, km: "KM", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, ft: "FT", callback?: Callback<Buffer>): Promise<Buffer>
    • geodistBuffer(key: RedisKey, member1: string | number | Buffer, member2: string | number | Buffer, mi: "MI", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • m: "M"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • km: "KM"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • ft: "FT"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member1: string | number | Buffer
      • member2: string | number | Buffer
      • mi: "MI"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    geohash

    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • geohash(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • geohash(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>

    • Returns members of a geospatial index as standard geohash strings

      • group: geo
      • complexity: O(log(N)) for each member requested, where N is the number of elements in the sorted set.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    geohashBuffer

    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    geopos

    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    geohashBuffer

    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • geohashBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    geopos

    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>
    • geopos(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<[longitude: string, latitude: string][]>

    • Returns longitude and latitude of members of a geospatial index

      • group: geo
      • complexity: O(N) where N is the number of members requested.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    georadius

    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<[longitude: string, latitude: string][]>]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<[longitude: string, latitude: string][]>

    georadius

    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • georadius(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown[]>

    • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown[]>

    georadius_ro

    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown[]>

    georadius_ro

    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadius_ro(...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]): Promise<unknown>

    • A read-only variant for GEORADIUS

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.10
      -

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember

    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember

    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>

    • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember_ro

    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    georadiusbymember_ro

    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • georadiusbymember_ro(...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]): Promise<unknown>

    • A read-only variant for GEORADIUSBYMEMBER

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
      • since: 3.2.10
      -

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    geosearch

    • geosearch(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • geosearch(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<unknown[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

      Returns Promise<unknown>

    geosearch

    • geosearch(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • geosearch(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<unknown[]>

    • Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
      • since: 6.2.0
      -

      Parameters

      Returns Promise<unknown[]>

    • Parameters

      Returns Promise<unknown[]>

    geosearchstore

    geosearchstore

    • Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.

      • group: geo
      • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
      • since: 6.2.0
      -

      Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    get

    • get(key: RedisKey, callback?: Callback<string>): Promise<string>

    get

    • get(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Get the value of a key

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    getBuffer

    • getBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getBuiltinCommands

    • getBuiltinCommands(): string[]
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    getBuffer

    • getBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getBuiltinCommands

    • getBuiltinCommands(): string[]

    • Return supported builtin commands

      -

      Returns string[]

    getbit

    • getbit(key: RedisKey, offset: string | number, callback?: Callback<number>): Promise<number>

    getbit

    • getbit(key: RedisKey, offset: string | number, callback?: Callback<number>): Promise<number>

    • Returns the bit value at offset in the string value stored at key

      • group: bitmap
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • offset: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    getdel

    • getdel(key: RedisKey, callback?: Callback<string>): Promise<string>

    getdel

    • getdel(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Get the value of a key and delete the key

      • group: string
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    getdelBuffer

    • getdelBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getex

    • getex(key: RedisKey, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, persist: "PERSIST", callback?: Callback<string>): Promise<string>

    getdelBuffer

    • getdelBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    getex

    • getex(key: RedisKey, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<string>): Promise<string>
    • getex(key: RedisKey, persist: "PERSIST", callback?: Callback<string>): Promise<string>

    • Get the value of a key and optionally set its expiration

      • group: string
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<string>

      Returns Promise<string>

    getexBuffer

    • getexBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, persist: "PERSIST", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getrange

    • getrange(key: RedisKey, start: string | number, end: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<string>

      Returns Promise<string>

    getexBuffer

    • getexBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, secondsToken: "EX", seconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<Buffer>): Promise<Buffer>
    • getexBuffer(key: RedisKey, persist: "PERSIST", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • persist: "PERSIST"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getrange

    • getrange(key: RedisKey, start: string | number, end: string | number, callback?: Callback<string>): Promise<string>

    • Get a substring of the string stored at a key

      • group: string
      • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
      • since: 2.4.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    getrangeBuffer

    • getrangeBuffer(key: RedisKey, start: string | number, end: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getset

    • getset(key: RedisKey, value: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    getrangeBuffer

    • getrangeBuffer(key: RedisKey, start: string | number, end: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    getset

    • getset(key: RedisKey, value: string | number | Buffer, callback?: Callback<string>): Promise<string>

    • Set the string value of a key and return its old value

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    getsetBuffer

    • getsetBuffer(key: RedisKey, value: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hdel

    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    getsetBuffer

    • getsetBuffer(key: RedisKey, value: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hdel

    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • hdel(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<number>

    • Delete one or more hash fields

      • group: hash
      • complexity: O(N) where N is the number of fields to be removed.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<number>

    hello

    • hello(callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    hello

    • hello(callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • hello(protover: string | number, usernamePasswordToken: "AUTH", username: string | Buffer, password: string | Buffer, clientnameToken: "SETNAME", clientname: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    • Handshake with Redis

      • group: connection
      • complexity: O(1)
      • since: 6.0.0
      -

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    hexists

    • hexists(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • protover: string | number
      • usernamePasswordToken: "AUTH"
      • username: string | Buffer
      • password: string | Buffer
      • clientnameToken: "SETNAME"
      • clientname: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    hexists

    • hexists(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>

    • Determine if a hash field exists

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hget

    • hget(key: RedisKey, field: string | Buffer, callback?: Callback<string>): Promise<string>

    hget

    • hget(key: RedisKey, field: string | Buffer, callback?: Callback<string>): Promise<string>

    • Get the value of a hash field

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    hgetBuffer

    • hgetBuffer(key: RedisKey, field: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    hgetall

    • hgetall(key: RedisKey, callback?: Callback<Record<string, string>>): Promise<Record<string, string>>

    hgetBuffer

    • hgetBuffer(key: RedisKey, field: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    hgetall

    • hgetall(key: RedisKey, callback?: Callback<Record<string, string>>): Promise<Record<string, string>>

    • Get all the fields and values in a hash

      • group: hash
      • complexity: O(N) where N is the size of the hash.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, string>>

      Returns Promise<Record<string, string>>

    hgetallBuffer

    • hgetallBuffer(key: RedisKey, callback?: Callback<Record<string, Buffer>>): Promise<Record<string, Buffer>>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, Buffer>>

      Returns Promise<Record<string, Buffer>>

    hincrby

    • hincrby(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, string>>

      Returns Promise<Record<string, string>>

    hgetallBuffer

    • hgetallBuffer(key: RedisKey, callback?: Callback<Record<string, Buffer>>): Promise<Record<string, Buffer>>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Record<string, Buffer>>

      Returns Promise<Record<string, Buffer>>

    hincrby

    • hincrby(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<number>): Promise<number>

    • Increment the integer value of a hash field by the given number

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    hincrbyfloat

    • hincrbyfloat(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    hincrbyfloat

    • hincrbyfloat(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<string>): Promise<string>

    • Increment the float value of a hash field by the given amount

      • group: hash
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    hincrbyfloatBuffer

    • hincrbyfloatBuffer(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hkeys

    • hkeys(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    hincrbyfloatBuffer

    • hincrbyfloatBuffer(key: RedisKey, field: string | Buffer, increment: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • field: string | Buffer
      • increment: string | number
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    hkeys

    • hkeys(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    • Get all the fields in a hash

      • group: hash
      • complexity: O(N) where N is the size of the hash.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    hkeysBuffer

    • hkeysBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    hlen

    • hlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    hkeysBuffer

    • hkeysBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    hlen

    • hlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the number of fields in a hash

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    hmget

    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<string[]>

    hmget

    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • hmget(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<string[]>

    • Get the values of all the given hash fields

      • group: hash
      • complexity: O(N) where N is the number of fields being requested.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<string[]>

    hmgetBuffer

    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<Buffer[]>

    hmset

    • hmset(key: RedisKey, object: object, callback?: Callback<"OK">): Promise<"OK">
    • hmset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<"OK">
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<string[]>

    hmgetBuffer

    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • hmgetBuffer(...args: [key: RedisKey, ...fields: (string | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

      Returns Promise<Buffer[]>

    hmset

    • hmset(key: RedisKey, object: object, callback?: Callback<"OK">): Promise<"OK">
    • hmset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]): Promise<"OK">
    • hmset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<"OK">

    • Set multiple hash fields to multiple values

      • group: hash
      • complexity: O(N) where N is the number of fields being set.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<"OK">

    hrandfield

    • hrandfield(key: RedisKey, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • +

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<"OK">

    hrandfield

    • hrandfield(key: RedisKey, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, callback?: Callback<string | unknown[]>): Promise<string | unknown[]>
    • hrandfield(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<string | unknown[]>): Promise<string | unknown[]>

    • Get one or multiple random fields from a hash

      • group: hash
      • complexity: O(N) where N is the number of fields returned
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    hrandfieldBuffer

    • hrandfieldBuffer(key: RedisKey, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    hscan

    • hscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<string | unknown[]>

      Returns Promise<string | unknown[]>

    hrandfieldBuffer

    • hrandfieldBuffer(key: RedisKey, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>
    • hrandfieldBuffer(key: RedisKey, count: string | number, withvalues: "WITHVALUES", callback?: Callback<unknown[] | Buffer>): Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withvalues: "WITHVALUES"
      • Optional callback: Callback<unknown[] | Buffer>

      Returns Promise<unknown[] | Buffer>

    hscan

    • hscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • hscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate hash fields and associated values

      • group: hash
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
      • since: 2.8.0
      -

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    hscanBuffer

    • hscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    hscanBufferStream

    • hscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hscanStream

    • hscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hset

    • hset(key: RedisKey, object: object, callback?: Callback<number>): Promise<number>
    • hset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<number>): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    hscanBuffer

    • hscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • hscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    hscanBufferStream

    • hscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hscanStream

    • hscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    hset

    • hset(key: RedisKey, object: object, callback?: Callback<number>): Promise<number>
    • hset(key: RedisKey, map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<number>): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • hset(...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]): Promise<number>

    • Set the string value of a hash field

      • group: hash
      • complexity: O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<number>

    hsetnx

    • hsetnx(key: RedisKey, field: string | Buffer, value: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • object: object
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

      Returns Promise<number>

    hsetnx

    • hsetnx(key: RedisKey, field: string | Buffer, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Set the value of a hash field, only if the field does not exist

      • group: hash
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hstrlen

    • hstrlen(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hstrlen

    • hstrlen(key: RedisKey, field: string | Buffer, callback?: Callback<number>): Promise<number>

    • Get the length of the value of a hash field

      • group: hash
      • complexity: O(1)
      • since: 3.2.0
      -

      Parameters

      • key: RedisKey
      • field: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    hvals

    • hvals(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    hvals

    • hvals(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    • Get all the values in a hash

      • group: hash
      • complexity: O(N) where N is the size of the hash.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    hvalsBuffer

    • hvalsBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    incr

    • incr(key: RedisKey, callback?: Callback<number>): Promise<number>

    hvalsBuffer

    • hvalsBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    incr

    • incr(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Increment the integer value of a key by one

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    incrby

    • incrby(key: RedisKey, increment: string | number, callback?: Callback<number>): Promise<number>

    incrby

    • incrby(key: RedisKey, increment: string | number, callback?: Callback<number>): Promise<number>

    • Increment the integer value of a key by the given amount

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    incrbyfloat

    • incrbyfloat(key: RedisKey, increment: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • increment: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    incrbyfloat

    • incrbyfloat(key: RedisKey, increment: string | number, callback?: Callback<string>): Promise<string>

    • Increment the float value of a key by the given amount

      • group: string
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • increment: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    info

    • info(callback?: Callback<string>): Promise<string>
    • info(...args: [...sections: (string | Buffer)[], callback: Callback<string>]): Promise<string>
    • info(...args: (string | Buffer)[]): Promise<string>

    info

    • info(callback?: Callback<string>): Promise<string>
    • info(...args: [...sections: (string | Buffer)[], callback: Callback<string>]): Promise<string>
    • info(...args: (string | Buffer)[]): Promise<string>

    • Get information and statistics about the server

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • Rest ...args: [...sections: (string | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<string>

    keys

    • keys(pattern: string, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • Rest ...args: [...sections: (string | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<string>

    keys

    • keys(pattern: string, callback?: Callback<string[]>): Promise<string[]>

    • Find all keys matching the given pattern

      • group: generic
      • complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
      • since: 1.0.0
      -

      Parameters

      • pattern: string
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    keysBuffer

    • keysBuffer(pattern: string, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • pattern: string
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lastsave

    • lastsave(callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • pattern: string
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    keysBuffer

    • keysBuffer(pattern: string, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • pattern: string
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lastsave

    • lastsave(callback?: Callback<number>): Promise<number>

    • Get the UNIX time stamp of the last successful save to disk

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<number>

      Returns Promise<number>

    latency

    • latency(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • latency(subcommand: "GRAPH", event: string | Buffer, callback?: Callback<string>): Promise<string>
    • latency(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "HISTOGRAM", callback?: Callback<unknown>): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]): Promise<unknown>
    • latency(subcommand: "HISTORY", event: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "LATEST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "RESET", callback?: Callback<number>): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<number>

      Returns Promise<number>

    latency

    • latency(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • latency(subcommand: "GRAPH", event: string | Buffer, callback?: Callback<string>): Promise<string>
    • latency(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "HISTOGRAM", callback?: Callback<unknown>): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • latency(...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]): Promise<unknown>
    • latency(subcommand: "HISTORY", event: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "LATEST", callback?: Callback<unknown[]>): Promise<unknown[]>
    • latency(subcommand: "RESET", callback?: Callback<number>): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]): Promise<number>
    • latency(...args: [subcommand: "RESET", ...events: (string | Buffer)[]]): Promise<number>

    • Return a human readable latency analysis report.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Return a latency graph for the event.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "GRAPH"
      • event: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "GRAPH"
      • event: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Show helpful text about the different subcommands.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Return the cumulative distribution of latencies of a subset of commands or all.

      • group: server
      • complexity: O(N) where N is the number of commands with latency information being retrieved.
      • since: 7.0.0
      -

      Parameters

      • subcommand: "HISTOGRAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HISTOGRAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

      Returns Promise<unknown>

    • Return timestamp-latency samples for the event.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "HISTORY"
      • event: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HISTORY"
      • event: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Return the latest latency samples for all events.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "LATEST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "LATEST"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Reset latency data for one or more events.

      • group: server
      • complexity: O(1)
      • since: 2.8.13
      -

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

      Returns Promise<number>

    lcs

    • lcs(key1: RedisKey, key2: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

      Returns Promise<number>

    lcs

    • lcs(key1: RedisKey, key2: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, idx: "IDX", lenToken: "MINMATCHLEN", len: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, callback?: Callback<unknown>): Promise<unknown>
    • lcs(key1: RedisKey, key2: RedisKey, len: "LEN", idx: "IDX", lenToken: "MINMATCHLEN", len1: string | number, withmatchlen: "WITHMATCHLEN", callback?: Callback<unknown>): Promise<unknown>

    lindex

    • lindex(key: RedisKey, index: string | number, callback?: Callback<string>): Promise<string>

    lindex

    • lindex(key: RedisKey, index: string | number, callback?: Callback<string>): Promise<string>

    • Get an element from a list by its index

      • group: list
      • complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • index: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    lindexBuffer

    • lindexBuffer(key: RedisKey, index: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    linsert

    • linsert(key: RedisKey, before: "BEFORE", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • linsert(key: RedisKey, after: "AFTER", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>

    lindexBuffer

    • lindexBuffer(key: RedisKey, index: string | number, callback?: Callback<Buffer>): Promise<Buffer>

    linsert

    • linsert(key: RedisKey, before: "BEFORE", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • linsert(key: RedisKey, after: "AFTER", pivot: string | number | Buffer, element: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Insert an element before or after another element in a list

      • group: list
      • complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • before: "BEFORE"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • after: "AFTER"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    llen

    • llen(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • before: "BEFORE"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • after: "AFTER"
      • pivot: string | number | Buffer
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    llen

    • llen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the length of a list

      • group: list
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    lmove

    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<string>): Promise<string>

    lmove

    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<string>): Promise<string>
    • lmove(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<string>): Promise<string>

    • Pop an element from a list, push it to another list and return it

      • group: list
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • left1: "LEFT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • left: "LEFT"
      • right: "RIGHT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • left: "LEFT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • source: RedisKey
      • destination: RedisKey
      • right: "RIGHT"
      • right1: "RIGHT"
      • Optional callback: Callback<string>

      Returns Promise<string>

    lmoveBuffer

    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>

    lmpop

    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>

    lmoveBuffer

    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", left1: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, left: "LEFT", right: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", left: "LEFT", callback?: Callback<Buffer>): Promise<Buffer>
    • lmoveBuffer(source: RedisKey, destination: RedisKey, right: "RIGHT", right1: "RIGHT", callback?: Callback<Buffer>): Promise<Buffer>

    lmpop

    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>
    • lmpop(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: string, members: string[]]>

    • Pop elements from a list

      • group: list
      • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    lmpopBuffer

    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    lolwut

    • lolwut(callback?: Callback<string>): Promise<string>
    • lolwut(versionToken: "VERSION", version: string | number, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: string, members: string[]]>

    lmpopBuffer

    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>
    • lmpopBuffer(...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]): Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<[key: Buffer, members: Buffer[]]>]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

      Returns Promise<[key: Buffer, members: Buffer[]]>

    lolwut

    • lolwut(callback?: Callback<string>): Promise<string>
    • lolwut(versionToken: "VERSION", version: string | number, callback?: Callback<string>): Promise<string>

    • Display some computer art and the Redis version

      • group: server
      • complexity: undefined
      • since: 5.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • versionToken: "VERSION"
      • version: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    lpop

    • lpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • lpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • versionToken: "VERSION"
      • version: string | number
      • Optional callback: Callback<string>

      Returns Promise<string>

    lpop

    • lpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • lpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and get the first elements in a list

      • group: list
      • complexity: O(N) where N is the number of elements returned
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    lpopBuffer

    • lpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • lpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    lpos

    • lpos(key: RedisKey, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>

    lpopBuffer

    • lpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • lpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    lpos

    • lpos(key: RedisKey, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number>): Promise<number>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, callback?: Callback<number[]>): Promise<number[]>
    • lpos(key: RedisKey, element: string | number | Buffer, rankToken: "RANK", rank: string | number, numMatchesToken: "COUNT", numMatches: string | number, lenToken: "MAXLEN", len: string | number, callback?: Callback<number[]>): Promise<number[]>

    • Return the index of matching elements on a list

      • group: list
      • complexity: O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.
      • since: 6.0.6
      -

      Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    lpush

    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    • Parameters

      • key: RedisKey
      • element: string | number | Buffer
      • rankToken: "RANK"
      • rank: string | number
      • numMatchesToken: "COUNT"
      • numMatches: string | number
      • lenToken: "MAXLEN"
      • len: string | number
      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    lpush

    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Prepend one or multiple elements to a list

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lpushx

    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lpushx

    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • lpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Prepend an element to a list, only if the list exists

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 2.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lrange

    • lrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    lrange

    • lrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Get a range of elements from a list

      • group: list
      • complexity: O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    lrangeBuffer

    • lrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lrem

    • lrem(key: RedisKey, count: string | number, element: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    lrangeBuffer

    • lrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    lrem

    • lrem(key: RedisKey, count: string | number, element: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Remove elements from a list

      • group: list
      • complexity: O(N+M) where N is the length of the list and M is the number of elements removed.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • count: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    lset

    • lset(key: RedisKey, index: string | number, element: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • count: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    lset

    • lset(key: RedisKey, index: string | number, element: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">

    • Set the value of an element in a list by its index

      • group: list
      • complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • index: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    ltrim

    • ltrim(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • index: string | number
      • element: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    ltrim

    • ltrim(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Trim a list to the specified range

      • group: list
      • complexity: O(N) where N is the number of elements to be removed by the operation.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    memory

    • memory(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "MALLOC-STATS", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "PURGE", callback?: Callback<"OK">): Promise<"OK">
    • memory(subcommand: "STATS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "USAGE", key: RedisKey, callback?: Callback<number>): Promise<number>
    • memory(subcommand: "USAGE", key: RedisKey, countToken: "SAMPLES", count: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    memory

    • memory(subcommand: "DOCTOR", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "MALLOC-STATS", callback?: Callback<string>): Promise<string>
    • memory(subcommand: "PURGE", callback?: Callback<"OK">): Promise<"OK">
    • memory(subcommand: "STATS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • memory(subcommand: "USAGE", key: RedisKey, callback?: Callback<number>): Promise<number>
    • memory(subcommand: "USAGE", key: RedisKey, countToken: "SAMPLES", count: string | number, callback?: Callback<number>): Promise<number>

    • Outputs memory problems report

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "DOCTOR"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Show allocator internal stats

      • group: server
      • complexity: Depends on how much memory is allocated, could be slow
      • since: 4.0.0
      -

      Parameters

      • subcommand: "MALLOC-STATS"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • +

      Parameters

      • subcommand: "MALLOC-STATS"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Ask the allocator to release memory

      • group: server
      • complexity: Depends on how much memory is allocated, could be slow
      • since: 4.0.0
      -

      Parameters

      • subcommand: "PURGE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • +

      Parameters

      • subcommand: "PURGE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Show memory usage details

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "STATS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Estimate the memory usage of a key

      • group: server
      • complexity: O(N) where N is the number of samples.
      • since: 4.0.0
      -

      Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • countToken: "SAMPLES"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    mget

    • mget(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: RedisKey[]): Promise<string[]>
    • mget(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • subcommand: "USAGE"
      • key: RedisKey
      • countToken: "SAMPLES"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    mget

    • mget(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • mget(...args: RedisKey[]): Promise<string[]>
    • mget(...args: [keys: RedisKey[]]): Promise<string[]>

    • Get the values of all the given keys

      • group: string
      • complexity: O(N) where N is the number of keys to retrieve.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    mgetBuffer

    • mgetBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    migrate

    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]): Promise<"OK">
    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]): Promise<"OK">

    mgetBuffer

    • mgetBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • mgetBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • mgetBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    migrate

    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]): Promise<"OK">
    • migrate(...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]): Promise<"OK">

    • Atomically transfer a key from a Redis instance to another one.

      • group: generic
      • complexity: This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
      • since: 2.6.0
      -

      Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]

      Returns Promise<"OK">

    module

    • module(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LOAD", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(subcommand: "LOADEX", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]): Promise<unknown>
    • module(subcommand: "UNLOAD", name: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]

      Returns Promise<"OK">

    module

    • module(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LIST", callback?: Callback<unknown>): Promise<unknown>
    • module(subcommand: "LOAD", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(subcommand: "LOADEX", path: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]): Promise<unknown>
    • module(...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]): Promise<unknown>
    • module(subcommand: "UNLOAD", name: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List all modules loaded by the server

      • group: server
      • complexity: O(N) where N is the number of loaded modules.
      • since: 4.0.0
      -

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LIST"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Load a module

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "LOAD"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LOAD"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Load a module with extended parameters

      • group: server
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • subcommand: "LOADEX"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LOADEX"
      • path: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

      Returns Promise<unknown>

    • Unload a module

      • group: server
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "UNLOAD"
      • name: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    monitor

    • monitor(callback?: Callback<Redis>): Promise<Redis>
    • +

      Parameters

      • subcommand: "UNLOAD"
      • name: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    monitor

    • monitor(callback?: Callback<Redis>): Promise<Redis>

    • Listen for all requests received by the server in real time.

      This command will create a new connection to Redis and send a MONITOR command via the new connection in order to avoid disturbing @@ -1392,1106 +1392,1106 @@

      Parameters

      • Optional callback: Callback<Redis>

        The callback function. If omit, a promise will be returned.

        -

      Returns Promise<Redis>

    move

    • move(key: RedisKey, db: string | number, callback?: Callback<number>): Promise<number>

    Returns Promise<Redis>

    move

    • move(key: RedisKey, db: string | number, callback?: Callback<number>): Promise<number>

    • Move a key to another database

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • db: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    mset

    • mset(object: object, callback?: Callback<"OK">): Promise<"OK">
    • mset(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • mset(...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]): Promise<"OK">
    • mset(...args: (number | RedisKey)[]): Promise<"OK">

    mset

    • mset(object: object, callback?: Callback<"OK">): Promise<"OK">
    • mset(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • mset(...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]): Promise<"OK">
    • mset(...args: (number | RedisKey)[]): Promise<"OK">

    • Set multiple keys to multiple values

      • group: string
      • complexity: O(N) where N is the number of keys to set.
      • since: 1.0.1
      -

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      Returns Promise<"OK">

    msetnx

    • msetnx(object: object, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]): Promise<number>
    • msetnx(...args: (number | RedisKey)[]): Promise<number>
    • +

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]

      Returns Promise<"OK">

    • Parameters

      Returns Promise<"OK">

    msetnx

    • msetnx(object: object, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(map: Map<string | number | Buffer, string | number | Buffer>, callback?: Callback<"OK">): Promise<"OK">
    • msetnx(...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]): Promise<number>
    • msetnx(...args: (number | RedisKey)[]): Promise<number>

    • Set multiple keys to multiple values, only if none of the keys exist

      • group: string
      • complexity: O(N) where N is the number of keys to set.
      • since: 1.0.1
      -

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    multi

    object

    • object(subcommand: "ENCODING", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "FREQ", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "IDLETIME", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "REFCOUNT", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • object: object
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • map: Map<string | number | Buffer, string | number | Buffer>
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • Rest ...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    multi

    object

    • object(subcommand: "ENCODING", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "FREQ", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "IDLETIME", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • object(subcommand: "REFCOUNT", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    • Inspect the internal encoding of a Redis object

      • group: generic
      • complexity: O(1)
      • since: 2.2.3
      -

      Parameters

      • subcommand: "ENCODING"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "ENCODING"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the logarithmic access frequency counter of a Redis object

      • group: generic
      • complexity: O(1)
      • since: 4.0.0
      -

      Parameters

      • subcommand: "FREQ"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "FREQ"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: generic
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the time since a Redis object was last accessed

      • group: generic
      • complexity: O(1)
      • since: 2.2.3
      -

      Parameters

      • subcommand: "IDLETIME"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "IDLETIME"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the number of references to the value of the key

      • group: generic
      • complexity: O(1)
      • since: 2.2.3
      -

      Parameters

      • subcommand: "REFCOUNT"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    persist

    • persist(key: RedisKey, callback?: Callback<number>): Promise<number>

    persist

    • persist(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Remove the expiration from a key

      • group: generic
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpire

    • pexpire(key: RedisKey, milliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    pexpire

    • pexpire(key: RedisKey, milliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpire(key: RedisKey, milliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set a key's time to live in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpireat

    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • milliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpireat

    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, gt: "GT", callback?: Callback<number>): Promise<number>
    • pexpireat(key: RedisKey, unixTimeMilliseconds: string | number, lt: "LT", callback?: Callback<number>): Promise<number>

    • Set the expiration for a key as a UNIX timestamp specified in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpiretime

    • pexpiretime(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • gt: "GT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • unixTimeMilliseconds: string | number
      • lt: "LT"
      • Optional callback: Callback<number>

      Returns Promise<number>

    pexpiretime

    • pexpiretime(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the expiration Unix timestamp for a key in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 7.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    pfadd

    • pfadd(key: RedisKey, callback?: Callback<number>): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    pfadd

    • pfadd(key: RedisKey, callback?: Callback<number>): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • pfadd(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Adds the specified elements to the specified HyperLogLog.

      • group: hyperloglog
      • complexity: O(1) to add every element.
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    pfcount

    • pfcount(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: RedisKey[]): Promise<number>
    • pfcount(...args: [keys: RedisKey[]]): Promise<number>

    pfcount

    • pfcount(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • pfcount(...args: RedisKey[]): Promise<number>
    • pfcount(...args: [keys: RedisKey[]]): Promise<number>

    • Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

      • group: hyperloglog
      • complexity: O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.
      • since: 2.8.9
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    pfdebug

    • pfdebug(subcommand: string | Buffer, key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    pfdebug

    • pfdebug(subcommand: string | Buffer, key: RedisKey, callback?: Callback<unknown>): Promise<unknown>

    • Internal commands for debugging HyperLogLog values

      • group: hyperloglog
      • complexity: N/A
      • since: 2.8.9
      -

      Parameters

      • subcommand: string | Buffer
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pfmerge

    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[]]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[]]): Promise<"OK">
    • +

      Parameters

      • subcommand: string | Buffer
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pfmerge

    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, ...sourcekeys: RedisKey[]]): Promise<"OK">
    • pfmerge(...args: [destkey: RedisKey, sourcekeys: RedisKey[]]): Promise<"OK">

    pfselftest

    • pfselftest(callback?: Callback<unknown>): Promise<unknown>

    pfselftest

    • pfselftest(callback?: Callback<unknown>): Promise<unknown>

    • An internal command for testing HyperLogLog values

      • group: hyperloglog
      • complexity: N/A
      • since: 2.8.9
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    ping

    • ping(callback?: Callback<"PONG">): Promise<"PONG">
    • ping(message: string | Buffer, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    ping

    • ping(callback?: Callback<"PONG">): Promise<"PONG">
    • ping(message: string | Buffer, callback?: Callback<string>): Promise<string>

    • Ping the server

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"PONG">

      Returns Promise<"PONG">

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    pingBuffer

    • pingBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    pipeline

    psetex

    • psetex(key: RedisKey, milliseconds: string | number, value: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Optional callback: Callback<"PONG">

      Returns Promise<"PONG">

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    pingBuffer

    • pingBuffer(message: string | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • message: string | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    pipeline

    psetex

    • psetex(key: RedisKey, milliseconds: string | number, value: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Set the value and expiration in milliseconds of a key

      • group: string
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    psubscribe

    • psubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • psubscribe(...args: string[]): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • milliseconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    psubscribe

    • psubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • psubscribe(...args: string[]): Promise<unknown>

    • Listen for messages published to channels matching the given patterns

      • group: pubsub
      • complexity: O(N) where N is the number of patterns the client is already subscribed to.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    psync

    • psync(replicationid: string | number | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    psync

    • psync(replicationid: string | number | Buffer, offset: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Internal command used for replication

      • group: server
      • complexity: undefined
      • since: 2.8.0
      -

      Parameters

      • replicationid: string | number | Buffer
      • offset: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pttl

    • pttl(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • replicationid: string | number | Buffer
      • offset: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    pttl

    • pttl(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the time to live for a key in milliseconds

      • group: generic
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    publish

    • publish(channel: string | Buffer, message: string | Buffer, callback?: Callback<number>): Promise<number>

    publish

    • publish(channel: string | Buffer, message: string | Buffer, callback?: Callback<number>): Promise<number>

    • Post a message to a channel

      • group: pubsub
      • complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).
      • since: 2.0.0
      -

      Parameters

      • channel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    pubsub

    • pubsub(subcommand: "CHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "CHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMPAT", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDNUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]): Promise<unknown[]>
    • +

      Parameters

      • channel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    pubsub

    • pubsub(subcommand: "CHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "CHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "HELP", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMPAT", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "NUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDCHANNELS", pattern: string, callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(subcommand: "SHARDNUMSUB", callback?: Callback<unknown[]>): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • pubsub(...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]): Promise<unknown[]>

    • List active channels

      • group: pubsub
      • complexity: O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)
      • since: 2.8.0
      -

      Parameters

      • subcommand: "CHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "CHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "CHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "CHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Show helpful text about the different subcommands

      • group: pubsub
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get the count of unique patterns pattern subscriptions

      • group: pubsub
      • complexity: O(1)
      • since: 2.8.0
      -

      Parameters

      • subcommand: "NUMPAT"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "NUMPAT"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get the count of subscribers for channels

      • group: pubsub
      • complexity: O(N) for the NUMSUB subcommand, where N is the number of requested channels
      • since: 2.8.0
      -

      Parameters

      • subcommand: "NUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "NUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    • List active shard channels

      • group: pubsub
      • complexity: O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).
      • since: 7.0.0
      -

      Parameters

      • subcommand: "SHARDCHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "SHARDCHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • +

      Parameters

      • subcommand: "SHARDCHANNELS"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • subcommand: "SHARDCHANNELS"
      • pattern: string
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Get the count of subscribers for shard channels

      • group: pubsub
      • complexity: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels
      • since: 7.0.0
      -

      Parameters

      • subcommand: "SHARDNUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    punsubscribe

    • punsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • punsubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • punsubscribe(...args: string[]): Promise<unknown>
    • +

      Parameters

      • subcommand: "SHARDNUMSUB"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

      Returns Promise<unknown[]>

    punsubscribe

    • punsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • punsubscribe(...args: [...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • punsubscribe(...args: string[]): Promise<unknown>

    • Stop listening for messages posted to channels matching the given patterns

      • group: pubsub
      • complexity: O(N+M) where N is the number of patterns the client is already subscribed and M is the number of total patterns subscribed in the system (by any client).
      • since: 2.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    quit

    • quit(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: string[]

      Returns Promise<unknown>

    quit

    • quit(callback?: Callback<"OK">): Promise<"OK">

    • Close the connection

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    randomkey

    • randomkey(callback?: Callback<string>): Promise<string>

    randomkey

    • randomkey(callback?: Callback<string>): Promise<string>

    • Return a random key from the keyspace

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    randomkeyBuffer

    • randomkeyBuffer(callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    readonly

    • readonly(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<string>

      Returns Promise<string>

    randomkeyBuffer

    • randomkeyBuffer(callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    readonly

    • readonly(callback?: Callback<"OK">): Promise<"OK">

    • Enables read queries for a connection to a cluster replica node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    readwrite

    • readwrite(callback?: Callback<"OK">): Promise<"OK">

    readwrite

    • readwrite(callback?: Callback<"OK">): Promise<"OK">

    • Disables read queries for a connection to a cluster replica node

      • group: cluster
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    rename

    • rename(key: RedisKey, newkey: RedisKey, callback?: Callback<"OK">): Promise<"OK">

    rename

    • rename(key: RedisKey, newkey: RedisKey, callback?: Callback<"OK">): Promise<"OK">

    • Rename a key

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      Returns Promise<"OK">

    renamenx

    • renamenx(key: RedisKey, newkey: RedisKey, callback?: Callback<number>): Promise<number>

    renamenx

    • renamenx(key: RedisKey, newkey: RedisKey, callback?: Callback<number>): Promise<number>

    • Rename a key, only if the new key does not exist

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      Returns Promise<number>

    replconf

    • replconf(callback?: Callback<unknown>): Promise<unknown>

    replconf

    • replconf(callback?: Callback<unknown>): Promise<unknown>

    • An internal command for configuring the replication stream

      • group: server
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    replicaof

    • replicaof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    replicaof

    • replicaof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Make the server a replica of another instance, or promote it as master.

      • group: server
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    reset

    • reset(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    reset

    • reset(callback?: Callback<"OK">): Promise<"OK">

    • Reset the connection

      • group: connection
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    restore

    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">

    restore

    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • restore(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Create a key using the provided serialized value, previously obtained using DUMP.

      • group: generic
      • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
      • since: 2.6.0
      -

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    restore-asking

    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    restore-asking

    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, callback?: Callback<unknown>): Promise<unknown>
    • restore-asking(key: RedisKey, ttl: string | number, serializedValue: string | number | Buffer, replace: "REPLACE", absttl: "ABSTTL", secondsToken: "IDLETIME", seconds: string | number, frequencyToken: "FREQ", frequency: string | number, callback?: Callback<unknown>): Promise<unknown>

    • An internal command for migrating keys in a cluster

      • group: server
      • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
      • since: 3.0.0
      -

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    role

    • role(callback?: Callback<unknown[]>): Promise<unknown[]>
    • +

      Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • ttl: string | number
      • serializedValue: string | number | Buffer
      • replace: "REPLACE"
      • absttl: "ABSTTL"
      • secondsToken: "IDLETIME"
      • seconds: string | number
      • frequencyToken: "FREQ"
      • frequency: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    role

    • role(callback?: Callback<unknown[]>): Promise<unknown[]>

    • Return the role of the instance in the context of replication

      • group: server
      • complexity: O(1)
      • since: 2.8.12
      -

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    rpop

    • rpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • rpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    rpop

    • rpop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • rpop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and get the last elements in a list

      • group: list
      • complexity: O(N) where N is the number of elements returned
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    rpopBuffer

    • rpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • rpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    rpoplpush

    • rpoplpush(source: RedisKey, destination: RedisKey, callback?: Callback<string>): Promise<string>

    rpopBuffer

    • rpopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • rpopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    rpoplpush

    • rpoplpush(source: RedisKey, destination: RedisKey, callback?: Callback<string>): Promise<string>

    • Remove the last element in a list, prepend it to another list and return it

      • group: list
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      Returns Promise<string>

    rpoplpushBuffer

    • rpoplpushBuffer(source: RedisKey, destination: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    rpush

    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    rpoplpushBuffer

    • rpoplpushBuffer(source: RedisKey, destination: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>

    rpush

    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpush(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Append one or multiple elements to a list

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    rpushx

    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    rpushx

    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • rpushx(...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]): Promise<number>

    • Append an element to a list, only if the list exists

      • group: list
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 2.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    sadd

    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

      Returns Promise<number>

    sadd

    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • sadd(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • sadd(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    • Add one or more members to a set

      • group: set
      • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    save

    • save(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    save

    • save(callback?: Callback<"OK">): Promise<"OK">

    • Synchronously save the dataset to disk

      • group: server
      • complexity: O(N) where N is the total number of keys in all databases
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    scan

    • scan(cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    scan

    • scan(cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • scan(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate the keys space

      • group: generic
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
      • since: 2.8.0
      -

      Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    scanBuffer

    • scanBuffer(cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    scanBufferStream

    • scanBufferStream(options?: ScanStreamOptions): default

    • Parameters

      • Optional options: ScanStreamOptions

      Returns default

    scanStream

    • scanStream(options?: ScanStreamOptions): default

    • Parameters

      • Optional options: ScanStreamOptions

      Returns default

    scard

    • scard(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    scanBuffer

    • scanBuffer(cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • scanBuffer(cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, typeToken: "TYPE", type: string | Buffer, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • typeToken: "TYPE"
      • type: string | Buffer
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    scanBufferStream

    • scanBufferStream(options?: ScanStreamOptions): default

    • Parameters

      • Optional options: ScanStreamOptions

      Returns default

    scanStream

    • scanStream(options?: ScanStreamOptions): default

    • Parameters

      • Optional options: ScanStreamOptions

      Returns default

    scard

    • scard(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the number of members in a set

      • group: set
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    script

    • script(subcommand: "DEBUG", yes: "YES", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", no: "NO", callback?: Callback<unknown>): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]): Promise<unknown>
    • script(subcommand: "FLUSH", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "KILL", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "LOAD", script: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    script

    • script(subcommand: "DEBUG", yes: "YES", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "DEBUG", no: "NO", callback?: Callback<unknown>): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • script(...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]): Promise<unknown>
    • script(subcommand: "FLUSH", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", async: "ASYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "FLUSH", sync: "SYNC", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "KILL", callback?: Callback<unknown>): Promise<unknown>
    • script(subcommand: "LOAD", script: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Set the debug mode for executed scripts.

      • group: scripting
      • complexity: O(1)
      • since: 3.2.0
      -

      Parameters

      • subcommand: "DEBUG"
      • yes: "YES"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • no: "NO"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "DEBUG"
      • yes: "YES"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "DEBUG"
      • no: "NO"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Check existence of scripts in the script cache.

      • group: scripting
      • complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
      • since: 2.6.0
      -

      Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

      Returns Promise<unknown>

    • +

      Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

      Returns Promise<unknown>

    • Remove all the scripts from the script cache.

      • group: scripting
      • complexity: O(N) with N being the number of scripts in cache
      • since: 2.6.0
      -

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "FLUSH"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • async: "ASYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "FLUSH"
      • sync: "SYNC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: scripting
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Kill the script currently in execution.

      • group: scripting
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "KILL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Load the specified Lua script into the script cache.

      • group: scripting
      • complexity: O(N) with N being the length in bytes of the script body.
      • since: 2.6.0
      -

      Parameters

      • subcommand: "LOAD"
      • script: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sdiff

    • sdiff(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: RedisKey[]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • subcommand: "LOAD"
      • script: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sdiff

    • sdiff(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sdiff(...args: RedisKey[]): Promise<string[]>
    • sdiff(...args: [keys: RedisKey[]]): Promise<string[]>

    • Subtract multiple sets

      • group: set
      • complexity: O(N) where N is the total number of elements in all given sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    sdiffBuffer

    • sdiffBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sdiffstore

    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    sdiffBuffer

    • sdiffBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sdiffBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sdiffBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sdiffstore

    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sdiffstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    select

    • select(index: string | number, callback?: Callback<"OK">): Promise<"OK">

    select

    • select(index: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Change the selected database for the current connection

      • group: connection
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • index: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    set

    • set(key: RedisKey, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • index: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    set

    • set(key: RedisKey, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<string>): Promise<string>
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", callback?: Callback<"OK">): Promise<"OK">
    • set(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<string>): Promise<string>

    • Set the string value of a key

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    setBuffer

    • setBuffer(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    setbit

    • setbit(key: RedisKey, offset: string | number, value: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<string>

      Returns Promise<string>

    setBuffer

    • setBuffer(key: RedisKey, value: string | number | Buffer, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, secondsToken: "EX", seconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, millisecondsToken: "PX", milliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", nx: "NX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>
    • setBuffer(key: RedisKey, value: string | number | Buffer, keepttl: "KEEPTTL", xx: "XX", get: "GET", callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • secondsToken: "EX"
      • seconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • millisecondsToken: "PX"
      • milliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeSecondsToken: "EXAT"
      • unixTimeSeconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • unixTimeMillisecondsToken: "PXAT"
      • unixTimeMilliseconds: string | number
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • nx: "NX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • keepttl: "KEEPTTL"
      • xx: "XX"
      • get: "GET"
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    setbit

    • setbit(key: RedisKey, offset: string | number, value: string | number, callback?: Callback<number>): Promise<number>

    • Sets or clears the bit at offset in the string value stored at key

      • group: bitmap
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    setex

    • setex(key: RedisKey, seconds: string | number, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    setex

    • setex(key: RedisKey, seconds: string | number, value: string | number | Buffer, callback?: Callback<"OK">): Promise<"OK">

    • Set the value and expiration of a key

      • group: string
      • complexity: O(1)
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • seconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    setnx

    • setnx(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • seconds: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    setnx

    • setnx(key: RedisKey, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Set the value of a key, only if the key does not exist

      • group: string
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    setrange

    • setrange(key: RedisKey, offset: string | number, value: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    setrange

    • setrange(key: RedisKey, offset: string | number, value: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Overwrite part of a string at key starting at the specified offset

      • group: string
      • complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    shutdown

    • shutdown(callback?: Callback<"OK">): Promise<"OK">
    • shutdown(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • offset: string | number
      • value: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    shutdown

    • shutdown(callback?: Callback<"OK">): Promise<"OK">
    • shutdown(abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(nosave: "NOSAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", callback?: Callback<"OK">): Promise<"OK">
    • shutdown(save: "SAVE", now: "NOW", force: "FORCE", abort: "ABORT", callback?: Callback<"OK">): Promise<"OK">

    • Synchronously save the dataset to disk and then shut down the server

      • group: server
      • complexity: O(N) when saving, where N is the total number of keys in all databases when saving data, otherwise O(1)
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sinter

    • sinter(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: RedisKey[]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • nosave: "NOSAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    • Parameters

      • save: "SAVE"
      • now: "NOW"
      • force: "FORCE"
      • abort: "ABORT"
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sinter

    • sinter(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sinter(...args: RedisKey[]): Promise<string[]>
    • sinter(...args: [keys: RedisKey[]]): Promise<string[]>

    • Intersect multiple sets

      • group: set
      • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    sinterBuffer

    • sinterBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sintercard

    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>

    sinterBuffer

    • sinterBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sinterBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sinterBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sintercard

    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • sintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • sintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>

    • Intersect multiple sets and return the cardinality of the result

      • group: set
      • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    sinterstore

    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    sinterstore

    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sinterstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    • Intersect multiple sets and store the resulting set in a key

      • group: set
      • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    sismember

    • sismember(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    sismember

    • sismember(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Determine if a given value is a member of a set

      • group: set
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    slaveof

    • slaveof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    slaveof

    • slaveof(host: string | Buffer, port: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Make the server a replica of another instance, or promote it as master.

      • group: server
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    slowlog

    • slowlog(subcommand: "GET", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "GET", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "RESET", callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • host: string | Buffer
      • port: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    slowlog

    • slowlog(subcommand: "GET", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "GET", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "LEN", callback?: Callback<unknown>): Promise<unknown>
    • slowlog(subcommand: "RESET", callback?: Callback<unknown>): Promise<unknown>

    • Get the slow log's entries

      • group: server
      • complexity: O(N) where N is the number of entries returned
      • since: 2.2.12
      -

      Parameters

      • subcommand: "GET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "GET"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "GET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "GET"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: server
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get the slow log's length

      • group: server
      • complexity: O(1)
      • since: 2.2.12
      -

      Parameters

      • subcommand: "LEN"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "LEN"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Clear all entries from the slow log

      • group: server
      • complexity: O(N) where N is the number of entries in the slowlog
      • since: 2.2.12
      -

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    smembers

    • smembers(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • subcommand: "RESET"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    smembers

    • smembers(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>

    • Get all the members in a set

      • group: set
      • complexity: O(N) where N is the set cardinality.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    smembersBuffer

    • smembersBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    smismember

    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number[]>

    smembersBuffer

    • smembersBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    smismember

    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]): Promise<number[]>
    • smismember(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number[]>
    • smismember(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number[]>

    • Returns the membership associated with the given elements for a set

      • group: set
      • complexity: O(N) where N is the number of elements being checked for membership
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    smove

    • smove(source: RedisKey, destination: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number[]>

    smove

    • smove(source: RedisKey, destination: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Move a member from one set to another

      • group: set
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • source: RedisKey
      • destination: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    sort

    sort

    • Sort the elements in a list, set or sorted set

      • group: generic
      • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
      • since: 1.0.0
      -

      Parameters

      Returns Promise<unknown>

    • Parameters

      Returns Promise<unknown>

    sort_ro

    • sort_ro(key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>

    sort_ro

    • sort_ro(key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, asc: "ASC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, desc: "DESC", alpha: "ALPHA", callback?: Callback<unknown>): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]): Promise<unknown>
    • sort_ro(...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]): Promise<unknown>

    • Sort the elements in a list, set or sorted set. Read-only variant of SORT.

      • group: generic
      • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
      • since: 7.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    spop

    • spop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • spop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • asc: "ASC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • patternToken: "BY"
      • pattern: string
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • desc: "DESC"
      • alpha: "ALPHA"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

      Returns Promise<unknown>

    spop

    • spop(key: RedisKey, callback?: Callback<string>): Promise<string>
    • spop(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and return one or multiple random members from a set

      • group: set
      • complexity: Without the count argument O(1), otherwise O(N) where N is the value of the passed count.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    spopBuffer

    • spopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • spopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    spublish

    • spublish(shardchannel: string | Buffer, message: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    spopBuffer

    • spopBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • spopBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    spublish

    • spublish(shardchannel: string | Buffer, message: string | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • Post a message to a shard channel

      • group: pubsub
      • complexity: O(N) where N is the number of clients subscribed to the receiving shard channel.
      • since: 7.0.0
      -

      Parameters

      • shardchannel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    srandmember

    • srandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • srandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • shardchannel: string | Buffer
      • message: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    srandmember

    • srandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • srandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Get one or multiple random members from a set

      • group: set
      • complexity: Without the count argument O(1), otherwise O(N) where N is the absolute value of the passed count.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    srandmemberBuffer

    • srandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • srandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    srem

    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    srandmemberBuffer

    • srandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • srandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    srem

    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • srem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • srem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    • Remove one or more members from a set

      • group: set
      • complexity: O(N) where N is the number of members to be removed.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    sscan

    • sscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    sscan

    • sscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • sscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate Set elements

      • group: set
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
      • since: 2.8.0
      -

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    sscanBuffer

    • sscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    sscanBufferStream

    • sscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    sscanStream

    • sscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    ssubscribe

    • ssubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • ssubscribe(...args: (string | Buffer)[]): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    sscanBuffer

    • sscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • sscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    sscanBufferStream

    • sscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    sscanStream

    • sscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    ssubscribe

    • ssubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • ssubscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Listen for messages published to the given shard channels

      • group: pubsub
      • complexity: O(N) where N is the number of shard channels to subscribe to.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    strlen

    • strlen(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    strlen

    • strlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the length of the value stored in a key

      • group: string
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    subscribe

    • subscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • subscribe(...args: (string | Buffer)[]): Promise<unknown>

    subscribe

    • subscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • subscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Listen for messages published to the given channels

      • group: pubsub
      • complexity: O(N) where N is the number of channels to subscribe to.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    substr

    • substr(key: RedisKey, start: string | number, end: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    substr

    • substr(key: RedisKey, start: string | number, end: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Get a substring of the string stored at a key

      • group: string
      • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sunion

    • sunion(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: RedisKey[]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[]]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • end: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    sunion

    • sunion(...args: [...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • sunion(...args: RedisKey[]): Promise<string[]>
    • sunion(...args: [keys: RedisKey[]]): Promise<string[]>

    • Add multiple sets

      • group: set
      • complexity: O(N) where N is the total number of elements in all given sets.
      • since: 1.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    • Parameters

      Returns Promise<string[]>

    sunionBuffer

    • sunionBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sunionstore

    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    sunionBuffer

    • sunionBuffer(...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • sunionBuffer(...args: RedisKey[]): Promise<Buffer[]>
    • sunionBuffer(...args: [keys: RedisKey[]]): Promise<Buffer[]>

    sunionstore

    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, ...keys: RedisKey[]]): Promise<number>
    • sunionstore(...args: [destination: RedisKey, keys: RedisKey[]]): Promise<number>

    sunsubscribe

    • sunsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • sunsubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • sunsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    sunsubscribe

    • sunsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • sunsubscribe(...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • sunsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Stop listening for messages posted to the given shard channels

      • group: pubsub
      • complexity: O(N) where N is the number of clients already subscribed to a shard channel.
      • since: 7.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    swapdb

    • swapdb(index1: string | number, index2: string | number, callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    swapdb

    • swapdb(index1: string | number, index2: string | number, callback?: Callback<"OK">): Promise<"OK">

    • Swaps two Redis databases

      • group: server
      • complexity: O(N) where N is the count of clients watching or blocking on keys from both databases.
      • since: 4.0.0
      -

      Parameters

      • index1: string | number
      • index2: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sync

    • sync(callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • index1: string | number
      • index2: string | number
      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    sync

    • sync(callback?: Callback<unknown>): Promise<unknown>

    • Internal command used for replication

      • group: server
      • complexity: undefined
      • since: 1.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    time

    • time(callback?: Callback<number[]>): Promise<number[]>
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    time

    • time(callback?: Callback<number[]>): Promise<number[]>

    • Return the current server time

      • group: server
      • complexity: O(1)
      • since: 2.6.0
      -

      Parameters

      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    touch

    • touch(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: RedisKey[]): Promise<number>
    • touch(...args: [keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Optional callback: Callback<number[]>

      Returns Promise<number[]>

    touch

    • touch(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • touch(...args: RedisKey[]): Promise<number>
    • touch(...args: [keys: RedisKey[]]): Promise<number>

    • Alters the last access time of a key(s). Returns the number of existing keys specified.

      • group: generic
      • complexity: O(N) where N is the number of keys that will be touched.
      • since: 3.2.1
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    ttl

    • ttl(key: RedisKey, callback?: Callback<number>): Promise<number>

    ttl

    • ttl(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the time to live for a key in seconds

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    type

    • type(key: RedisKey, callback?: Callback<string>): Promise<string>

    type

    • type(key: RedisKey, callback?: Callback<string>): Promise<string>

    • Determine the type stored at key

      • group: generic
      • complexity: O(1)
      • since: 1.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    unlink

    • unlink(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: RedisKey[]): Promise<number>
    • unlink(...args: [keys: RedisKey[]]): Promise<number>

    unlink

    • unlink(...args: [...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: [keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • unlink(...args: RedisKey[]): Promise<number>
    • unlink(...args: [keys: RedisKey[]]): Promise<number>

    • Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

      • group: generic
      • complexity: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
      • since: 4.0.0
      -

      Parameters

      • Rest ...args: [...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    unsubscribe

    • unsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • unsubscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • unsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    unsubscribe

    • unsubscribe(callback?: Callback<unknown>): Promise<unknown>
    • unsubscribe(...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]): Promise<unknown>
    • unsubscribe(...args: (string | Buffer)[]): Promise<unknown>

    • Stop listening for messages posted to the given channels

      • group: pubsub
      • complexity: O(N) where N is the number of clients already subscribed to a channel.
      • since: 2.0.0
      -

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    unwatch

    • unwatch(callback?: Callback<"OK">): Promise<"OK">
    • +

      Parameters

      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: (string | Buffer)[]

      Returns Promise<unknown>

    unwatch

    • unwatch(callback?: Callback<"OK">): Promise<"OK">

    • Forget about all watched keys

      • group: transactions
      • complexity: O(1)
      • since: 2.2.0
      -

      Parameters

      • Optional callback: Callback<"OK">

      Returns Promise<"OK">

    wait

    • wait(numreplicas: string | number, timeout: string | number, callback?: Callback<number>): Promise<number>

    wait

    • wait(numreplicas: string | number, timeout: string | number, callback?: Callback<number>): Promise<number>

    • Wait for the synchronous replication of all the write commands sent in the context of the current connection

      • group: generic
      • complexity: O(1)
      • since: 3.0.0
      -

      Parameters

      • numreplicas: string | number
      • timeout: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    watch

    • watch(...args: [...keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: [keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: RedisKey[]): Promise<"OK">
    • watch(...args: [keys: RedisKey[]]): Promise<"OK">
    • +

      Parameters

      • numreplicas: string | number
      • timeout: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    watch

    • watch(...args: [...keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: [keys: RedisKey[], callback: Callback<"OK">]): Promise<"OK">
    • watch(...args: RedisKey[]): Promise<"OK">
    • watch(...args: [keys: RedisKey[]]): Promise<"OK">

    xack

    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]): Promise<number>

    xack

    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xack(...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]): Promise<number>

    • Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.

      • group: stream
      • complexity: O(1) for each message ID processed.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xadd

    • +

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xadd

    • Appends a new entry to a stream

      • group: stream
      • complexity: O(1) when adding a new entry, O(N) when trimming where N being the number of entries evicted.
      • since: 5.0.0
      -

      Parameters

      Returns Promise<string>

    • Parameters

      Returns Promise<string>

    xaddBuffer

    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<Buffer>]): Promise<Buffer>
    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<Buffer>

    xautoclaim

    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>

    xaddBuffer

    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<Buffer>]): Promise<Buffer>
    • xaddBuffer(...args: [key: RedisKey, ...args: RedisValue[]]): Promise<Buffer>

    xautoclaim

    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xautoclaim(key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, justid: "JUSTID", callback?: Callback<unknown[]>): Promise<unknown[]>

    • Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.

      • group: stream
      • complexity: O(1) if COUNT is small.
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xclaim

    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • +

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • consumer: string | Buffer
      • minIdleTime: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • justid: "JUSTID"
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xclaim

    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>
    • xclaim(...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]): Promise<unknown[]>

    • Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.

      • group: stream
      • complexity: O(log N) with N being the number of messages in the PEL of the consumer group.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    xdel

    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

      Returns Promise<unknown[]>

    xdel

    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • xdel(...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]): Promise<number>

    • Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.

      • group: stream
      • complexity: O(1) for each single item to delete in the stream, regardless of the stream size.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xgroup

    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATECONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DELCONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DESTROY", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

      Returns Promise<number>

    xgroup

    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATE", key: RedisKey, groupname: string | Buffer, newId: "$", mkstream: "MKSTREAM", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "CREATECONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DELCONSUMER", key: RedisKey, groupname: string | Buffer, consumername: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "DESTROY", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, id: string | number | Buffer, entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", callback?: Callback<unknown>): Promise<unknown>
    • xgroup(subcommand: "SETID", key: RedisKey, groupname: string | Buffer, newId: "$", entriesReadToken: "ENTRIESREAD", entriesRead: string | number, callback?: Callback<unknown>): Promise<unknown>

    • Create a consumer group.

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "CREATE"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • mkstream: "MKSTREAM"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Create a consumer in a consumer group.

      • group: stream
      • complexity: O(1)
      • since: 6.2.0
      -

      Parameters

      • subcommand: "CREATECONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CREATECONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Delete a consumer from a consumer group.

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "DELCONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "DELCONSUMER"
      • key: RedisKey
      • groupname: string | Buffer
      • consumername: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Destroy a consumer group.

      • group: stream
      • complexity: O(N) where N is the number of entries in the group's pending entries list (PEL).
      • since: 5.0.0
      -

      Parameters

      • subcommand: "DESTROY"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "DESTROY"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Set a consumer group to an arbitrary last delivered ID value.

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xinfo

    • xinfo(subcommand: "CONSUMERS", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "GROUPS", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", countToken: "COUNT", count: string | number, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • id: string | number | Buffer
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "SETID"
      • key: RedisKey
      • groupname: string | Buffer
      • newId: "$"
      • entriesReadToken: "ENTRIESREAD"
      • entriesRead: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xinfo

    • xinfo(subcommand: "CONSUMERS", key: RedisKey, groupname: string | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "GROUPS", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "HELP", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", callback?: Callback<unknown>): Promise<unknown>
    • xinfo(subcommand: "STREAM", key: RedisKey, fullToken: "FULL", countToken: "COUNT", count: string | number, callback?: Callback<unknown>): Promise<unknown>

    • List the consumers in a consumer group

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "CONSUMERS"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "CONSUMERS"
      • key: RedisKey
      • groupname: string | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • List the consumer groups of a stream

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "GROUPS"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "GROUPS"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Show helpful text about the different subcommands

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • +

      Parameters

      • subcommand: "HELP"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Get information about a stream

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xlen

    • xlen(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • subcommand: "STREAM"
      • key: RedisKey
      • fullToken: "FULL"
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xlen

    • xlen(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Return the number of entries in a stream

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    xpending

    • xpending(key: RedisKey, group: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    xpending

    • xpending(key: RedisKey, group: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, callback?: Callback<unknown[]>): Promise<unknown[]>
    • xpending(key: RedisKey, group: string | Buffer, minIdleTimeToken: "IDLE", minIdleTime: string | number, start: string | number | Buffer, end: string | number | Buffer, count: string | number, consumer: string | Buffer, callback?: Callback<unknown[]>): Promise<unknown[]>

    • Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.

      • group: stream
      • complexity: O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xrange

    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • +

      Parameters

      • key: RedisKey
      • group: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    • Parameters

      • key: RedisKey
      • group: string | Buffer
      • minIdleTimeToken: "IDLE"
      • minIdleTime: string | number
      • start: string | number | Buffer
      • end: string | number | Buffer
      • count: string | number
      • consumer: string | Buffer
      • Optional callback: Callback<unknown[]>

      Returns Promise<unknown[]>

    xrange

    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrange(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>

    • Return a range of elements in a stream, with IDs matching the specified IDs interval

      • group: stream
      • complexity: O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrangeBuffer

    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xread

    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • +

      Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrangeBuffer

    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrangeBuffer(key: RedisKey, start: string | number | Buffer, end: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • start: string | number | Buffer
      • end: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xread

    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]): Promise<[key: string, items: [id: string, fields: string[]][]][]>
    • xread(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.

      • group: stream
      • complexity: For each stream mentioned: O(N) with N being the number of elements being returned, it means that XREAD-ing with a fixed COUNT is O(1). Note that when the BLOCK option is used, XADD will pay O(M) time in order to serve the M clients blocked on the stream getting new data.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    xreadBuffer

    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    xreadgroup

    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • +

      Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: string, items: [id: string, fields: string[]][]][]>]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: string, items: [id: string, fields: string[]][]][]>

    xreadBuffer

    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>
    • xreadBuffer(...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    • Parameters

      • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

    xreadgroup

    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]): Promise<unknown[]>
    • xreadgroup(...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]): Promise<unknown[]>

    • Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.

      • group: stream
      • complexity: For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.
      • since: 5.0.0
      -

      Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    xrevrange

    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • +

      Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

      Returns Promise<unknown[]>

    • Parameters

      • Rest ...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

      Returns Promise<unknown[]>

    xrevrange

    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>
    • xrevrange(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: string, fields: string[]][]>): Promise<[id: string, fields: string[]][]>

    • Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE

      • group: stream
      • complexity: O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrevrangeBuffer

    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xsetid

    • xsetid(key: RedisKey, lastId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: string, fields: string[]][]>

      Returns Promise<[id: string, fields: string[]][]>

    xrevrangeBuffer

    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>
    • xrevrangeBuffer(key: RedisKey, end: string | number | Buffer, start: string | number | Buffer, countToken: "COUNT", count: string | number, callback?: Callback<[id: Buffer, fields: Buffer[]][]>): Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    • Parameters

      • key: RedisKey
      • end: string | number | Buffer
      • start: string | number | Buffer
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[id: Buffer, fields: Buffer[]][]>

      Returns Promise<[id: Buffer, fields: Buffer[]][]>

    xsetid

    • xsetid(key: RedisKey, lastId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, callback?: Callback<unknown>): Promise<unknown>
    • xsetid(key: RedisKey, lastId: string | number | Buffer, entriesAddedToken: "ENTRIESADDED", entriesAdded: string | number, maxDeletedEntryIdToken: "MAXDELETEDID", maxDeletedEntryId: string | number | Buffer, callback?: Callback<unknown>): Promise<unknown>

    • An internal command for replicating stream values

      • group: stream
      • complexity: O(1)
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xtrim

    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    • Parameters

      • key: RedisKey
      • lastId: string | number | Buffer
      • entriesAddedToken: "ENTRIESADDED"
      • entriesAdded: string | number
      • maxDeletedEntryIdToken: "MAXDELETEDID"
      • maxDeletedEntryId: string | number | Buffer
      • Optional callback: Callback<unknown>

      Returns Promise<unknown>

    xtrim

    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, maxlen: "MAXLEN", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", equal: "=", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • xtrim(key: RedisKey, minid: "MINID", approximately: "~", threshold: string | number | Buffer, countToken: "LIMIT", count: string | number, callback?: Callback<number>): Promise<number>

    • Trims the stream to (approximately if '~' is passed) a certain size

      • group: stream
      • complexity: O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zadd

    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • maxlen: "MAXLEN"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • equal: "="
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • key: RedisKey
      • minid: "MINID"
      • approximately: "~"
      • threshold: string | number | Buffer
      • countToken: "LIMIT"
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zadd

    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]): Promise<number>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]): Promise<string>
    • zadd(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<string>

    • Add one or more members to a sorted set, or update its score if it already exists

      • group: sorted-set
      • complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
      • since: 1.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    zaddBuffer

    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    zcard

    • zcard(key: RedisKey, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

      Returns Promise<string>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<string>

    zaddBuffer

    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]): Promise<Buffer>
    • zaddBuffer(...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]): Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

      Returns Promise<Buffer>

    • Parameters

      • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

      Returns Promise<Buffer>

    zcard

    • zcard(key: RedisKey, callback?: Callback<number>): Promise<number>

    • Get the number of members in a sorted set

      • group: sorted-set
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<number>

      Returns Promise<number>

    zcount

    • zcount(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>

    zcount

    • zcount(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>

    • Count the members in a sorted set with scores within the given values

      • group: sorted-set
      • complexity: O(log(N)) with N being the number of elements in the sorted set.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zdiff

    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zdiff

    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zdiff(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>

    • Subtract multiple sorted sets

      • group: sorted-set
      • complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zdiffBuffer

    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zdiffstore

    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zdiffBuffer

    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zdiffBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zdiffstore

    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zdiffstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>

    • Subtract multiple sorted sets and store the resulting sorted set in a new key

      • group: sorted-set
      • complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    zincrby

    • zincrby(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<string>): Promise<string>

    zincrby

    • zincrby(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<string>): Promise<string>

    • Increment the score of a member in a sorted set

      • group: sorted-set
      • complexity: O(log(N)) where N is the number of elements in the sorted set.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zincrbyBuffer

    • zincrbyBuffer(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zinter

    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zincrbyBuffer

    • zincrbyBuffer(key: RedisKey, increment: string | number, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • increment: string | number
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zinter

    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zinter(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>

    • Intersect multiple sorted sets

      • group: sorted-set
      • complexity: O(NK)+O(Mlog(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zinterBuffer

    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zintercard

    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zinterBuffer

    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zinterBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zintercard

    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]): Promise<number>
    • zintercard(...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>
    • zintercard(...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]): Promise<number>

    • Intersect multiple sorted sets and return the cardinality of the result

      • group: sorted-set
      • complexity: O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    zinterstore

    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

      Returns Promise<number>

    zinterstore

    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zinterstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>

    • Intersect multiple sorted sets and store the resulting sorted set in a new key

      • group: sorted-set
      • complexity: O(NK)+O(Mlog(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    zlexcount

    • zlexcount(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    zlexcount

    • zlexcount(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Count the number of members in a sorted set between a given lexicographical range

      • group: sorted-set
      • complexity: O(log(N)) with N being the number of elements in the sorted set.
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zmpop

    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zmpop

    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>
    • zmpop(...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]): Promise<unknown>

    • Remove and return members with scores in a sorted set

      • group: sorted-set
      • complexity: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 7.0.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    zmscore

    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

      Returns Promise<unknown>

    zmscore

    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<string[]>
    • zmscore(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<string[]>

    • Get the score associated with the given members in a sorted set

      • group: sorted-set
      • complexity: O(N) where N is the number of members being requested.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    zmscoreBuffer

    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    zpopmax

    • zpopmax(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmax(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<string[]>

    zmscoreBuffer

    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<Buffer[]>
    • zmscoreBuffer(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<Buffer[]>

    zpopmax

    • zpopmax(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmax(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and return members with the highest scores in a sorted set

      • group: sorted-set
      • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zpopmaxBuffer

    • zpopmaxBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopmaxBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zpopmin

    • zpopmin(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmin(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    zpopmaxBuffer

    • zpopmaxBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopmaxBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zpopmin

    • zpopmin(key: RedisKey, callback?: Callback<string[]>): Promise<string[]>
    • zpopmin(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Remove and return members with the lowest scores in a sorted set

      • group: sorted-set
      • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
      • since: 5.0.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zpopminBuffer

    • zpopminBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopminBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zrandmember

    • zrandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • zrandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrandmember(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    zpopminBuffer

    • zpopminBuffer(key: RedisKey, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zpopminBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    zrandmember

    • zrandmember(key: RedisKey, callback?: Callback<string>): Promise<string>
    • zrandmember(key: RedisKey, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrandmember(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    • Get one or multiple random elements from a sorted set

      • group: sorted-set
      • complexity: O(N) where N is the number of elements returned
      • since: 6.2.0
      -

      Parameters

      • key: RedisKey
      • Optional callback: Callback<string>

      Returns Promise<string>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrandmemberBuffer

    • zrandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • zrandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrandmemberBuffer(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrange

    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    zrandmemberBuffer

    • zrandmemberBuffer(key: RedisKey, callback?: Callback<Buffer>): Promise<Buffer>
    • zrandmemberBuffer(key: RedisKey, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrandmemberBuffer(key: RedisKey, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    • Parameters

      • key: RedisKey
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrange

    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrange(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangeBuffer

    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebylex

    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangeBuffer

    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangeBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebylex

    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by lexicographical range

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebylexBuffer

    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebyscore

    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebylexBuffer

    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebylexBuffer(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangebyscore

    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrangebyscore(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by score

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 1.0.5
      -

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebyscoreBuffer

    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangestore

    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrangebyscoreBuffer

    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrangebyscoreBuffer(key: RedisKey, min: string | number, max: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrangestore

    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, byscore: "BYSCORE", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", callback?: Callback<number>): Promise<number>
    • zrangestore(dst: RedisKey, src: RedisKey, min: string | number | Buffer, max: string | number | Buffer, bylex: "BYLEX", rev: "REV", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<number>): Promise<number>

    • Store a range of members from sorted set into another key

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements stored into the destination key.
      • since: 6.2.0
      -

      Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrank

    • zrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • byscore: "BYSCORE"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • Optional callback: Callback<number>

      Returns Promise<number>

    • Parameters

      • dst: RedisKey
      • src: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • bylex: "BYLEX"
      • rev: "REV"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrank

    • zrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Determine the index of a member in a sorted set

      • group: sorted-set
      • complexity: O(log(N))
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrem

    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    zrem

    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]): Promise<number>
    • zrem(...args: [key: RedisKey, ...members: (string | number | Buffer)[]]): Promise<number>
    • zrem(...args: [key: RedisKey, members: (string | number | Buffer)[]]): Promise<number>

    • Remove one or more members from a sorted set

      • group: sorted-set
      • complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
      • since: 1.2.0
      -

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    zremrangebylex

    • zremrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

      Returns Promise<number>

    zremrangebylex

    • zremrangebylex(key: RedisKey, min: string | number | Buffer, max: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Remove all members in a sorted set between the given lexicographical range

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyrank

    • zremrangebyrank(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • min: string | number | Buffer
      • max: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyrank

    • zremrangebyrank(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<number>): Promise<number>

    • Remove all members in a sorted set within the given indexes

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyscore

    • zremrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zremrangebyscore

    • zremrangebyscore(key: RedisKey, min: string | number, max: string | number, callback?: Callback<number>): Promise<number>

    • Remove all members in a sorted set within the given scores

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrevrange

    • zrevrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrange(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • min: string | number
      • max: string | number
      • Optional callback: Callback<number>

      Returns Promise<number>

    zrevrange

    • zrevrange(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrange(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by index, with scores ordered from high to low

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangeBuffer

    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebylex

    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangeBuffer

    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangeBuffer(key: RedisKey, start: string | number, stop: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • start: string | number
      • stop: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebylex

    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebylex(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 2.8.9
      -

      Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebylexBuffer

    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebyscore

    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebylexBuffer

    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebylexBuffer(key: RedisKey, max: string | number | Buffer, min: string | number | Buffer, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number | Buffer
      • min: string | number | Buffer
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrangebyscore

    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<string[]>): Promise<string[]>
    • zrevrangebyscore(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<string[]>): Promise<string[]>

    • Return a range of members in a sorted set, by score, with scores ordered from high to low

      • group: sorted-set
      • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
      • since: 2.2.0
      -

      Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebyscoreBuffer

    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrank

    • zrevrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>
    • +

      Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<string[]>

      Returns Promise<string[]>

    zrevrangebyscoreBuffer

    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", callback?: Callback<Buffer[]>): Promise<Buffer[]>
    • zrevrangebyscoreBuffer(key: RedisKey, max: string | number, min: string | number, withscores: "WITHSCORES", offsetCountToken: "LIMIT", offset: string | number, count: string | number, callback?: Callback<Buffer[]>): Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    • Parameters

      • key: RedisKey
      • max: string | number
      • min: string | number
      • withscores: "WITHSCORES"
      • offsetCountToken: "LIMIT"
      • offset: string | number
      • count: string | number
      • Optional callback: Callback<Buffer[]>

      Returns Promise<Buffer[]>

    zrevrank

    • zrevrank(key: RedisKey, member: string | number | Buffer, callback?: Callback<number>): Promise<number>

    • Determine the index of a member in a sorted set, with scores ordered from high to low

      • group: sorted-set
      • complexity: O(log(N))
      • since: 2.0.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zscan

    • zscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • +

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<number>

      Returns Promise<number>

    zscan

    • zscan(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>
    • zscan(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: string, elements: string[]]>): Promise<[cursor: string, elements: string[]]>

    • Incrementally iterate sorted sets elements and associated scores

      • group: sorted-set
      • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
      • since: 2.8.0
      -

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    zscanBuffer

    • zscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    zscanBufferStream

    • zscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscanStream

    • zscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscore

    • zscore(key: RedisKey, member: string | number | Buffer, callback?: Callback<string>): Promise<string>
    • +

      Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: string, elements: string[]]>

      Returns Promise<[cursor: string, elements: string[]]>

    zscanBuffer

    • zscanBuffer(key: RedisKey, cursor: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>
    • zscanBuffer(key: RedisKey, cursor: string | number, patternToken: "MATCH", pattern: string, countToken: "COUNT", count: string | number, callback?: Callback<[cursor: Buffer, elements: Buffer[]]>): Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    • Parameters

      • key: RedisKey
      • cursor: string | number
      • patternToken: "MATCH"
      • pattern: string
      • countToken: "COUNT"
      • count: string | number
      • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

      Returns Promise<[cursor: Buffer, elements: Buffer[]]>

    zscanBufferStream

    • zscanBufferStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscanStream

    • zscanStream(key: string, options?: ScanStreamOptions): default

    • Parameters

      • key: string
      • Optional options: ScanStreamOptions

      Returns default

    zscore

    • zscore(key: RedisKey, member: string | number | Buffer, callback?: Callback<string>): Promise<string>

    • Get the score associated with the given member in a sorted set

      • group: sorted-set
      • complexity: O(1)
      • since: 1.2.0
      -

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zscoreBuffer

    • zscoreBuffer(key: RedisKey, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zunion

    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • +

      Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<string>

      Returns Promise<string>

    zscoreBuffer

    • zscoreBuffer(key: RedisKey, member: string | number | Buffer, callback?: Callback<Buffer>): Promise<Buffer>

    • Parameters

      • key: RedisKey
      • member: string | number | Buffer
      • Optional callback: Callback<Buffer>

      Returns Promise<Buffer>

    zunion

    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]): Promise<string[]>
    • zunion(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<string[]>

    • Add multiple sorted sets

      • group: sorted-set
      • complexity: O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
      • since: 6.2.0
      -

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zunionBuffer

    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zunionstore

    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • +

      Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

      Returns Promise<string[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<string[]>

    zunionBuffer

    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[]]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]): Promise<Buffer[]>
    • zunionBuffer(...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]): Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

      Returns Promise<Buffer[]>

    • Parameters

      • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

      Returns Promise<Buffer[]>

    zunionstore

    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]): Promise<number>
    • zunionstore(...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]): Promise<number>

    • Add multiple sorted sets and store the resulting sorted set in a new key

      • group: sorted-set
      • complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
      • since: 2.0.0
      -

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    Static createClient

    • createClient(...args: []): Redis
    • +

      Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

      Returns Promise<number>

    • Parameters

      • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

      Returns Promise<number>

    Static createClient

    • createClient(...args: []): Redis

    • Create a Redis instance. This is the same as new Redis() but is included for compatibility with node-redis.

      Parameters

      • Rest ...args: []

      Returns Redis

    Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/index.html b/docs/index.html index f3785b44..56f26eb3 100644 --- a/docs/index.html +++ b/docs/index.html @@ -1 +1 @@ -ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    ioredis

    Index

    References

    Classes

    Interfaces

    Type aliases

    Variables

    References

    default

    Renames and re-exports Redis

    Type aliases

    ClusterNode

    ClusterNode: string | number | { host?: string; port?: number }

    DNSLookupFunction

    DNSLookupFunction: (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void) => void

    Type declaration

      • (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void): void

      • Parameters

        • hostname: string
        • callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void
            • (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number): void

            • Parameters

              • err: NodeJS.ErrnoException | null | undefined
              • address: string
              • Optional family: number

              Returns void

        Returns void

    DNSResolveSrvFunction

    DNSResolveSrvFunction: (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void) => void

    Type declaration

      • (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void): void

      • Parameters

        • hostname: string
        • callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void
            • (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]): void

            • Parameters

              • err: NodeJS.ErrnoException | null | undefined
              • Optional records: SrvRecord[]

              Returns void

        Returns void

    NodeRole

    NodeRole: "master" | "slave" | "all"

    RedisKey

    RedisKey: string | Buffer

    RedisOptions

    RedisOptions: CommonRedisOptions & SentinelConnectionOptions & StandaloneConnectionOptions

    RedisValue

    RedisValue: string | Buffer | number

    StandaloneConnectionOptions

    StandaloneConnectionOptions: (Partial<TcpNetConnectOpts> & Partial<IpcNetConnectOpts>) & { disconnectTimeout?: number; tls?: ConnectionOptions }

    Variables

    Const ReplyError

    ReplyError: any = ...

    Generated using TypeDoc

    \ No newline at end of file +ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    ioredis

    Index

    References

    Classes

    Interfaces

    Type aliases

    Variables

    References

    default

    Renames and re-exports Redis

    Type aliases

    ClusterNode

    ClusterNode: string | number | { host?: string; port?: number }

    DNSLookupFunction

    DNSLookupFunction: (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void) => void

    Type declaration

      • (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void): void

      • Parameters

        • hostname: string
        • callback: (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number) => void
            • (err: NodeJS.ErrnoException | null | undefined, address: string, family?: number): void

            • Parameters

              • err: NodeJS.ErrnoException | null | undefined
              • address: string
              • Optional family: number

              Returns void

        Returns void

    DNSResolveSrvFunction

    DNSResolveSrvFunction: (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void) => void

    Type declaration

      • (hostname: string, callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void): void

      • Parameters

        • hostname: string
        • callback: (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]) => void
            • (err: NodeJS.ErrnoException | null | undefined, records?: SrvRecord[]): void

            • Parameters

              • err: NodeJS.ErrnoException | null | undefined
              • Optional records: SrvRecord[]

              Returns void

        Returns void

    NodeRole

    NodeRole: "master" | "slave" | "all"

    RedisKey

    RedisKey: string | Buffer

    RedisOptions

    RedisOptions: CommonRedisOptions & SentinelConnectionOptions & StandaloneConnectionOptions

    RedisValue

    RedisValue: string | Buffer | number

    StandaloneConnectionOptions

    StandaloneConnectionOptions: (Partial<TcpNetConnectOpts> & Partial<IpcNetConnectOpts>) & { disconnectTimeout?: number; tls?: ConnectionOptions }

    Variables

    Const ReplyError

    ReplyError: any = ...

    Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/interfaces/ChainableCommander.html b/docs/interfaces/ChainableCommander.html index 937e7b48..98fe061e 100644 --- a/docs/interfaces/ChainableCommander.html +++ b/docs/interfaces/ChainableCommander.html @@ -1,2451 +1,2451 @@ -ChainableCommander | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface ChainableCommander

    Hierarchy

    • RedisCommander<{ type: "pipeline" }>
      • ChainableCommander

    Index

    Properties

    Methods

    Properties

    length

    length: number

    Methods

    acl

    • acl(subcommand: "CAT", callback?: Callback<unknown>): ChainableCommander
    • acl(subcommand: "CAT", categoryname: string | Buffer, callback?: Callback<unknown>): ChainableCommander
    • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]): ChainableCommander
    • acl(...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]): ChainableCommander
    • acl(subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, callback?: Callback<string>): ChainableCommander
    • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]): ChainableCommander
    • acl(...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]): ChainableCommander
    • acl(subcommand: "GENPASS", callback?: Callback<string>): ChainableCommander
    • acl(subcommand: "GENPASS", bits: string | number, callback?: Callback<string>): ChainableCommander
    • acl(subcommand: "GETUSER", username: string | Buffer, callback?: Callback<string[]>): ChainableCommander
    • acl(subcommand: "HELP", callback?: Callback<unknown>): ChainableCommander
    • acl(subcommand: "LIST", callback?: Callback<string[]>): ChainableCommander
    • acl(subcommand: "LOAD", callback?: Callback<"OK">): ChainableCommander
    • acl(subcommand: "LOG", callback?: Callback<unknown>): ChainableCommander
    • acl(subcommand: "LOG", count: string | number, callback?: Callback<unknown>): ChainableCommander
    • acl(subcommand: "LOG", reset: "RESET", callback?: Callback<unknown>): ChainableCommander
    • acl(subcommand: "SAVE", callback?: Callback<"OK">): ChainableCommander
    • acl(subcommand: "SETUSER", username: string | Buffer, callback?: Callback<"OK">): ChainableCommander
    • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]): ChainableCommander
    • acl(...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]): ChainableCommander
    • acl(subcommand: "USERS", callback?: Callback<string[]>): ChainableCommander
    • acl(subcommand: "WHOAMI", callback?: Callback<string>): ChainableCommander

    Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/interfaces/ClusterOptions.html b/docs/interfaces/ClusterOptions.html index 4eccbc99..1eb91ee4 100644 --- a/docs/interfaces/ClusterOptions.html +++ b/docs/interfaces/ClusterOptions.html @@ -1,80 +1,80 @@ ClusterOptions | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface ClusterOptions

    Options for Cluster constructor

    -

    Hierarchy

    • CommanderOptions
      • ClusterOptions

    Index

    Properties

    Methods

    Properties

    Optional autoPipeliningIgnoredCommands

    autoPipeliningIgnoredCommands?: string[]
    +

    Hierarchy

    • CommanderOptions
      • ClusterOptions

    Index

    Properties

    Methods

    Properties

    Optional autoPipeliningIgnoredCommands

    autoPipeliningIgnoredCommands?: string[]

    See Redis class.

    default

    []

    -

    Optional dnsLookup

    dnsLookup?: DNSLookupFunction
    +

    Optional dnsLookup

    dnsLookup?: DNSLookupFunction

    Hostnames will be resolved to IP addresses via this function. This is needed when the addresses of startup nodes are hostnames instead of IPs.

    You may provide a custom lookup function when you want to customize the cache behavior of the default function.

    default

    require('dns').lookup

    -

    Optional enableAutoPipelining

    enableAutoPipelining?: boolean
    +

    Optional enableAutoPipelining

    enableAutoPipelining?: boolean

    See Redis class.

    default

    false

    -

    Optional enableOfflineQueue

    enableOfflineQueue?: boolean
    +

    Optional enableOfflineQueue

    enableOfflineQueue?: boolean

    See Redis class.

    default

    true

    -

    Optional enableReadyCheck

    enableReadyCheck?: boolean
    +

    Optional enableReadyCheck

    enableReadyCheck?: boolean

    When enabled, ioredis only emits "ready" event when CLUSTER INFO command reporting the cluster is ready for handling commands.

    default

    true

    -

    Optional keyPrefix

    keyPrefix?: string

    Optional lazyConnect

    lazyConnect?: boolean
    +

    Optional keyPrefix

    keyPrefix?: string

    Optional lazyConnect

    lazyConnect?: boolean

    By default, When a new Cluster instance is created, it will connect to the Redis cluster automatically. If you want to keep the instance disconnected until the first command is called, set this option to true.

    default

    false

    -

    Optional maxRedirections

    maxRedirections?: number
    +

    Optional maxRedirections

    maxRedirections?: number

    When a MOVED or ASK error is received, client will redirect the command to another node. This option limits the max redirections allowed to send a command.

    default

    16

    -

    Optional natMap

    natMap?: NatMap

    Optional redisOptions

    redisOptions?: Omit<RedisOptions, "port" | "host" | "path" | "retryStrategy" | "readOnly" | "enableOfflineQueue" | "sentinels">
    +

    Optional natMap

    natMap?: NatMap

    Optional redisOptions

    redisOptions?: Omit<RedisOptions, "port" | "host" | "path" | "retryStrategy" | "readOnly" | "enableOfflineQueue" | "sentinels">

    Passed to the constructor of Redis

    default

    null

    -

    Optional resolveSrv

    resolveSrv?: DNSResolveSrvFunction
    +

    Optional resolveSrv

    resolveSrv?: DNSResolveSrvFunction

    SRV records will be resolved via this function.

    You may provide a custom resolveSrv function when you want to customize the cache behavior of the default function.

    default

    require('dns').resolveSrv

    -

    Optional retryDelayOnClusterDown

    retryDelayOnClusterDown?: number
    +

    Optional retryDelayOnClusterDown

    retryDelayOnClusterDown?: number

    When a CLUSTERDOWN error is received, client will retry if retryDelayOnClusterDown is valid delay time (in ms).

    default

    100

    -

    Optional retryDelayOnFailover

    retryDelayOnFailover?: number
    +

    Optional retryDelayOnFailover

    retryDelayOnFailover?: number

    When an error is received when sending a command (e.g. "Connection is closed." when the target Redis node is down), client will retry if retryDelayOnFailover is valid delay time (in ms).

    default

    100

    -

    Optional retryDelayOnMoved

    retryDelayOnMoved?: number
    +

    Optional retryDelayOnMoved

    retryDelayOnMoved?: number

    By default, this value is 0, which means when a MOVED error is received, the client will resend the command instantly to the node returned together with the MOVED error. However, sometimes it takes time for a cluster to become state stabilized after a failover, so adding a delay before resending can prevent a ping pong effect.

    default

    0

    -

    Optional retryDelayOnTryAgain

    retryDelayOnTryAgain?: number
    +

    Optional retryDelayOnTryAgain

    retryDelayOnTryAgain?: number

    When a TRYAGAIN error is received, client will retry if retryDelayOnTryAgain is valid delay time (in ms).

    default

    100

    -

    Optional scaleReads

    scaleReads?: Function | NodeRole
    +

    Optional scaleReads

    scaleReads?: Function | NodeRole

    Scale reads to the node with the specified role.

    default

    "master"

    -

    Optional scripts

    scripts?: Record<string, { lua: string; numberOfKeys?: number; readOnly?: boolean }>
    +

    Optional scripts

    scripts?: Record<string, { lua: string; numberOfKeys?: number; readOnly?: boolean }>

    Custom LUA commands

    -

    Optional showFriendlyErrorStack

    showFriendlyErrorStack?: boolean

    Optional slotsRefreshInterval

    slotsRefreshInterval?: number
    +

    Optional showFriendlyErrorStack

    showFriendlyErrorStack?: boolean

    Optional slotsRefreshInterval

    slotsRefreshInterval?: number

    The milliseconds between every automatic slots refresh.

    default

    5000

    -

    Optional slotsRefreshTimeout

    slotsRefreshTimeout?: number
    +

    Optional slotsRefreshTimeout

    slotsRefreshTimeout?: number

    The milliseconds before a timeout occurs while refreshing slots from the cluster.

    default

    1000

    -

    Optional useSRVRecords

    useSRVRecords?: boolean
    +

    Optional useSRVRecords

    useSRVRecords?: boolean

    Discover nodes using SRV records

    default

    false

    -

    Methods

    Optional clusterRetryStrategy

    • clusterRetryStrategy(times: number, reason?: Error): number | void

    Methods

    Optional clusterRetryStrategy

    • clusterRetryStrategy(times: number, reason?: Error): number | void

    • See "Quick Start" section.

      default

      (times) => Math.min(100 + times * 2, 2000)

      Parameters

      • times: number
      • Optional reason: Error

      Returns number | void

    Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/interfaces/CommonRedisOptions.html b/docs/interfaces/CommonRedisOptions.html index 2fd5c829..fed04481 100644 --- a/docs/interfaces/CommonRedisOptions.html +++ b/docs/interfaces/CommonRedisOptions.html @@ -1,49 +1,49 @@ -CommonRedisOptions | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface CommonRedisOptions

    Hierarchy

    • CommanderOptions
      • CommonRedisOptions

    Index

    Properties

    Methods

    Properties

    Optional Connector

    Connector?: ConnectorConstructor

    Optional autoPipeliningIgnoredCommands

    autoPipeliningIgnoredCommands?: string[]
    default

    []

    -

    Optional autoResendUnfulfilledCommands

    autoResendUnfulfilledCommands?: boolean
    +CommonRedisOptions | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface CommonRedisOptions

    Hierarchy

    • CommanderOptions
      • CommonRedisOptions

    Index

    Properties

    Methods

    Properties

    Optional Connector

    Connector?: ConnectorConstructor

    Optional autoPipeliningIgnoredCommands

    autoPipeliningIgnoredCommands?: string[]
    default

    []

    +

    Optional autoResendUnfulfilledCommands

    autoResendUnfulfilledCommands?: boolean

    Whether or not to resend unfulfilled commands on reconnect. Unfulfilled commands are most likely to be blocking commands such as brpop or blpop.

    default

    true

    -

    Optional autoResubscribe

    autoResubscribe?: boolean
    +

    Optional autoResubscribe

    autoResubscribe?: boolean

    When the client reconnects, channels subscribed in the previous connection will be resubscribed automatically if autoResubscribe is true.

    default

    true

    -

    Optional commandQueue

    commandQueue?: boolean

    Optional commandTimeout

    commandTimeout?: number
    +

    Optional commandQueue

    commandQueue?: boolean

    Optional commandTimeout

    commandTimeout?: number

    If a command does not return a reply within a set number of milliseconds, a "Command timed out" error will be thrown.

    -

    Optional connectTimeout

    connectTimeout?: number
    +

    Optional connectTimeout

    connectTimeout?: number

    How long the client will wait before killing a socket due to inactivity during initial connection.

    default

    10000

    -

    Optional connectionName

    connectionName?: string
    +

    Optional connectionName

    connectionName?: string

    Set the name of the connection to make it easier to identity the connection in client list.

    link

    https://redis.io/commands/client-setname

    -

    Optional db

    db?: number
    +

    Optional db

    db?: number

    Database index to use.

    default

    0

    -

    Optional enableAutoPipelining

    enableAutoPipelining?: boolean
    default

    false

    -

    Optional enableOfflineQueue

    enableOfflineQueue?: boolean
    +

    Optional enableAutoPipelining

    enableAutoPipelining?: boolean
    default

    false

    +

    Optional enableOfflineQueue

    enableOfflineQueue?: boolean

    By default, if the connection to Redis server has not been established, commands are added to a queue and are executed once the connection is "ready" (when enableReadyCheck is true, "ready" means the Redis server has loaded the database from disk, otherwise means the connection to the Redis server has been established). If this option is false, when execute the command when the connection isn't ready, an error will be returned.

    default

    true

    -

    Optional enableReadyCheck

    enableReadyCheck?: boolean
    +

    Optional enableReadyCheck

    enableReadyCheck?: boolean

    The client will sent an INFO command to check whether the server is still loading data from the disk ( which happens when the server is just launched) when the connection is established, and only wait until the loading process is finished before emitting the ready event.

    default

    true

    -

    Optional keepAlive

    keepAlive?: number
    +

    Optional keepAlive

    keepAlive?: number

    Enable/disable keep-alive functionality.

    link

    https://nodejs.org/api/net.html#socketsetkeepaliveenable-initialdelay

    default

    0

    -

    Optional keyPrefix

    keyPrefix?: string

    Optional lazyConnect

    lazyConnect?: boolean
    +

    Optional keyPrefix

    keyPrefix?: string

    Optional lazyConnect

    lazyConnect?: boolean

    When a Redis instance is initialized, a connection to the server is immediately established. Set this to true will delay the connection to the server until the first command is sent or redis.connect() is called explicitly.

    default

    false

    -

    Optional maxLoadingRetryTime

    maxLoadingRetryTime?: number
    default

    10000

    -

    Optional maxRetriesPerRequest

    maxRetriesPerRequest?: number
    +

    Optional maxLoadingRetryTime

    maxLoadingRetryTime?: number
    default

    10000

    +

    Optional maxRetriesPerRequest

    maxRetriesPerRequest?: number

    The commands that don't get a reply due to the connection to the server is lost are put into a queue and will be resent on reconnect (if allowed by the retryStrategy option). This option is used to configure how many reconnection attempts should be allowed before @@ -51,18 +51,18 @@ Set this options to null instead of a number to let commands wait forever until the connection is alive again.

    default

    20

    -

    Optional monitor

    monitor?: boolean
    +

    Optional monitor

    monitor?: boolean

    This option is used internally when you call redis.monitor() to tell Redis to enter the monitor mode when the connection is established.

    default

    false

    -

    Optional noDelay

    noDelay?: boolean
    +

    Optional noDelay

    noDelay?: boolean

    Enable/disable the use of Nagle's algorithm.

    link

    https://nodejs.org/api/net.html#socketsetnodelaynodelay

    default

    true

    -

    Optional offlineQueue

    offlineQueue?: boolean

    Optional password

    password?: string
    +

    Optional offlineQueue

    offlineQueue?: boolean

    Optional password

    password?: string

    If set, client will send AUTH command with the value of this option when connected.

    -

    Optional readOnly

    readOnly?: boolean
    default

    false

    -

    Optional reconnectOnError

    reconnectOnError?: ReconnectOnError
    +

    Optional readOnly

    readOnly?: boolean
    default

    false

    +

    Optional reconnectOnError

    reconnectOnError?: ReconnectOnError

    Whether or not to reconnect on certain Redis errors. This options by default is null, which means it should never reconnect on Redis errors. You can pass a function that accepts an Redis error, and returns:

    @@ -74,12 +74,12 @@
    example
    const redis = new Redis({
      reconnectOnError(err) {
        const targetError = "READONLY";
        if (err.message.includes(targetError)) {
          // Only reconnect when the error contains "READONLY"
          return true; // or `return 1;`
        }
      },
    });
    default

    null

    -

    Optional scripts

    scripts?: Record<string, { lua: string; numberOfKeys?: number; readOnly?: boolean }>
    default

    undefined

    -

    Optional showFriendlyErrorStack

    showFriendlyErrorStack?: boolean

    Optional stringNumbers

    stringNumbers?: boolean
    +

    Optional scripts

    scripts?: Record<string, { lua: string; numberOfKeys?: number; readOnly?: boolean }>
    default

    undefined

    +

    Optional showFriendlyErrorStack

    showFriendlyErrorStack?: boolean

    Optional stringNumbers

    stringNumbers?: boolean

    When enabled, numbers returned by Redis will be converted to JavaScript strings instead of numbers. This is necessary if you want to handle big numbers (above Number.MAX_SAFE_INTEGER === 2^53).

    default

    false

    -

    Optional username

    username?: string
    +

    Optional username

    username?: string

    If set, client will send AUTH command with the value of this option as the first argument when connected. This is supported since Redis 6.

    -

    Methods

    Optional retryStrategy

    • retryStrategy(times: number): number | void

    Legend

    • Constructor
    • Property
    • Method
    • Property
    • Method
    • Static property
    • Static method
    • Inherited method

    Settings

    Theme

    Generated using TypeDoc

    \ No newline at end of file +

    Methods

    Optional retryStrategy

    • retryStrategy(times: number): number | void

    Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/interfaces/SentinelAddress.html b/docs/interfaces/SentinelAddress.html index a764e695..19126e79 100644 --- a/docs/interfaces/SentinelAddress.html +++ b/docs/interfaces/SentinelAddress.html @@ -1 +1 @@ -SentinelAddress | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface SentinelAddress

    Hierarchy

    • SentinelAddress

    Index

    Properties

    Properties

    Optional family

    family?: number

    host

    host: string

    port

    port: number

    Generated using TypeDoc

    \ No newline at end of file +SentinelAddress | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface SentinelAddress

    Hierarchy

    • SentinelAddress

    Index

    Properties

    Properties

    Optional family

    family?: number

    host

    host: string

    port

    port: number

    Generated using TypeDoc

    \ No newline at end of file diff --git a/docs/interfaces/SentinelConnectionOptions.html b/docs/interfaces/SentinelConnectionOptions.html index 3c0a7093..7acaa65c 100644 --- a/docs/interfaces/SentinelConnectionOptions.html +++ b/docs/interfaces/SentinelConnectionOptions.html @@ -1,5 +1,5 @@ -SentinelConnectionOptions | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface SentinelConnectionOptions

    Hierarchy

    • SentinelConnectionOptions

    Index

    Properties

    Methods

    Properties

    Optional connectTimeout

    connectTimeout?: number

    Optional disconnectTimeout

    disconnectTimeout?: number

    Optional enableTLSForSentinelMode

    enableTLSForSentinelMode?: boolean

    Optional failoverDetector

    failoverDetector?: boolean

    Optional name

    name?: string
    +SentinelConnectionOptions | ioredis
    Options
    All
    • Public
    • Public/Protected
    • All
    Menu

    Interface SentinelConnectionOptions

    Hierarchy

    • SentinelConnectionOptions

    Index

    Properties

    Methods

    Properties

    Optional connectTimeout

    connectTimeout?: number

    Optional disconnectTimeout

    disconnectTimeout?: number

    Optional enableTLSForSentinelMode

    enableTLSForSentinelMode?: boolean

    Optional failoverDetector

    failoverDetector?: boolean

    Optional name

    name?: string

    Master group name of the Sentinel

    -

    Optional natMap

    natMap?: NatMap

    Optional preferredSlaves

    preferredSlaves?: PreferredSlaves

    Optional role

    role?: "master" | "slave"
    default

    "master"

    -

    Optional sentinelCommandTimeout

    sentinelCommandTimeout?: number

    Optional sentinelMaxConnections

    sentinelMaxConnections?: number
    default

    10

    -

    Optional sentinelPassword

    sentinelPassword?: string

    Optional sentinelTLS

    sentinelTLS?: ConnectionOptions

    Optional sentinelUsername

    sentinelUsername?: string

    Optional sentinels

    sentinels?: Partial<SentinelAddress>[]

    Optional tls

    tls?: ConnectionOptions

    Optional updateSentinels

    updateSentinels?: boolean

    Methods

    Optional sentinelReconnectStrategy

    • sentinelReconnectStrategy(retryAttempts: number): number | void

    Optional sentinelRetryStrategy

    • sentinelRetryStrategy(retryAttempts: number): number | void

    Legend

    • Constructor
    • Property
    • Method
    • Property
    • Method
    • Static property
    • Static method
    • Inherited method

    Settings

    Theme

    Generated using TypeDoc

    \ No newline at end of file +

    Optional natMap

    natMap?: NatMap

    Optional preferredSlaves

    preferredSlaves?: PreferredSlaves

    Optional role

    role?: "master" | "slave"
    default

    "master"

    +

    Optional sentinelCommandTimeout

    sentinelCommandTimeout?: number

    Optional sentinelMaxConnections

    sentinelMaxConnections?: number
    default

    10

    +

    Optional sentinelPassword

    sentinelPassword?: string

    Optional sentinelTLS

    sentinelTLS?: ConnectionOptions

    Optional sentinelUsername

    sentinelUsername?: string

    Optional sentinels

    sentinels?: Partial<SentinelAddress>[]

    Optional tls

    tls?: ConnectionOptions

    Optional updateSentinels

    updateSentinels?: boolean

    Methods

    Optional sentinelReconnectStrategy

    • sentinelReconnectStrategy(retryAttempts: number): number | void

    Optional sentinelRetryStrategy

    • sentinelRetryStrategy(retryAttempts: number): number | void

    Generated using TypeDoc

    \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index d1460624..51029fef 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "ioredis", - "version": "5.2.2", + "version": "5.2.3", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "ioredis", - "version": "5.2.2", + "version": "5.2.3", "license": "MIT", "dependencies": { "@ioredis/commands": "^1.1.1", diff --git a/package.json b/package.json index defef4d9..68b9cce3 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "ioredis", - "version": "5.2.2", + "version": "5.2.3", "description": "A robust, performance-focused and full-featured Redis client for Node.js.", "main": "./built/index.js", "types": "./built/index.d.ts",