Class Redis<ReplyMapping>

This is the major component of ioredis. 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");
}

Type Parameters

  • ReplyMapping extends ReplyMappingMode = "legacy"

Hierarchy

  • Commander<{
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>
  • EventEmitter
  • Transaction<ReplyMapping extends "resp3"
        ? "resp3"
        : "resp2">
    • Redis

Implements

  • DataHandledable

Constructors

constructor

Properties

options status Cluster Command

Accessors

autoPipelineQueueSize mode

Methods

_buildBatchContext acl aclBuffer addBuiltinCommand append arcount ardel ardelrange arget argetBuffer argetrange argetrangeBuffer argrep argrepBuffer arinfo arinfoBuffer arinsert arlastitems arlastitemsBuffer arlen armget armgetBuffer armset arnext arop aropBuffer arring arscan arscanBuffer arseek arset asking auth bgrewriteaof bgrewriteaofBuffer bgsave bitcount bitfield bitfield_ro bitop bitpos blmove blmoveBuffer blmovem blmovemBuffer blmpop blmpopBuffer blpop blpopBuffer brpop brpopBuffer brpoplpush brpoplpushBuffer bzmpop bzpopmax bzpopmaxBuffer bzpopmin bzpopminBuffer call callBuffer client clientBuffer cluster command config configBuffer connect copy createBuiltinCommand dbsize debug decr decrby defineCommand del discard disconnect dump dumpBuffer duplicate echo echoBuffer end eval eval_ro evalsha evalsha_ro exec exists expire expireat expiretime failover fcall fcall_ro flushall flushdb function functionBuffer geoadd geodist geodistBuffer geohash geohashBuffer geopos georadius georadius_ro georadiusbymember georadiusbymember_ro geosearch geosearchstore get getBuffer getBuiltinCommands getbit getdel getdelBuffer getex getexBuffer getrange getrangeBuffer getset getsetBuffer hdel hello hexists hexpire hexpireat hexpiretime hget hgetBuffer hgetall hgetallBuffer hgetdel hgetdelBuffer hgetex hgetexBuffer himport hincrby hincrbyfloat hincrbyfloatBuffer hkeys hkeysBuffer hlen hmget hmgetBuffer hmset hpersist hpexpire hpexpireat hpexpiretime hpttl hrandfield hrandfieldBuffer hscan hscanBuffer hscanBufferStream hscanStream hset hsetex hsetnx hstrlen httl hvals hvalsBuffer incr incrby incrbyfloat increx increxBuffer info keys keysBuffer lastsave latency lcs lindex lindexBuffer linsert llen lmove lmoveBuffer lmovem lmovemBuffer lmpop lmpopBuffer lolwut lpop lpopBuffer lpos lpush lpushx lrange lrangeBuffer lrem lset ltrim memory mget mgetBuffer migrate module monitor move mset msetex msetnx multi object on once persist pexpire pexpireat pexpiretime pfadd pfcount pfdebug pfmerge pfselftest ping pingBuffer pipeline psetex psubscribe psync pttl publish pubsub punsubscribe quit randomkey randomkeyBuffer readonly readwrite rename renamenx replconf replicaof reset restore restore-asking role rpop rpopBuffer rpoplpush rpoplpushBuffer rpush rpushx sadd save scan scanBuffer scanBufferStream scanStream scard script sdiff sdiffBuffer sdiffcard sdiffstore select set setBuffer setbit setex setnx setrange shutdown sinter sinterBuffer sintercard sinterstore sismember slaveof slowlog smembers smembersBuffer smismember smove sort sort_ro spop spopBuffer spublish srandmember srandmemberBuffer srem sscan sscanBuffer sscanBufferStream sscanStream ssubscribe strlen subscribe substr sunion sunionBuffer sunioncard sunionstore sunsubscribe swapdb sync time touch ttl type unlink unsubscribe unwatch vadd vcard vdim vemb vembBuffer vgetattr vgetattrBuffer vinfo vinfoBuffer vismember vlinks vlinksBuffer vrandmember vrandmemberBuffer vrange vrangeBuffer vrem vsetattr vsim vsimBuffer wait watch xack xadd xaddBuffer xautoclaim xclaim xdel xdelex xgroup xinfo xlen xnack xpending xrange xrangeBuffer xread xreadBuffer xreadgroup xreadgroupBuffer xrevrange xrevrangeBuffer xsetid xtrim zadd zaddBuffer zcard zcount zdiff zdiffBuffer zdiffstore zincrby zincrbyBuffer zinter zinterBuffer zintercard zinterstore zlexcount zmpop zmscore zmscoreBuffer zpopmax zpopmaxBuffer zpopmin zpopminBuffer zrandmember zrandmemberBuffer zrange zrangeBuffer zrangebylex zrangebylexBuffer zrangebyscore zrangebyscoreBuffer zrangestore zrank zrankBuffer zrem zremrangebylex zremrangebyrank zremrangebyscore zrevrange zrevrangeBuffer zrevrangebylex zrevrangebylexBuffer zrevrangebyscore zrevrangebyscoreBuffer zrevrank zrevrankBuffer zscan zscanBuffer zscanBufferStream zscanStream zscore zscoreBuffer zunion zunionBuffer zunionstore createClient

Constructors

constructor

Properties

options

options: RedisOptions

status

status: RedisStatus = "wait"

Static Cluster

Cluster: typeof Cluster = Cluster

Static Command

Command: typeof Command = Command

Accessors

autoPipelineQueueSize

  • get autoPipelineQueueSize(): number

  • Returns 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

_buildBatchContext

acl

  • acl(subcommand, callback?): Promise<unknown>

  • Lists 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>

  • acl(subcommand, category, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • acl(...args): Promise<number>

  • Deletes ACL users, and terminates their connections.

    • 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>

  • acl(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • acl(subcommand, username, command, callback?): Promise<string>

  • Simulates the execution of a command by a user, 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>

  • acl(...args): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • acl(...args): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • acl(subcommand, callback?): Promise<string>

  • Generates a pseudorandom, secure password that can be used to identify ACL users.

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

    Parameters

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

    Returns Promise<string>

  • acl(subcommand, bits, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • acl(subcommand, username, callback?): Promise<string[]>

  • Lists the ACL rules of a 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[]>

  • acl(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • acl(subcommand, callback?): Promise<string[]>

  • Dumps the effective rules in ACL 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[]>

  • acl(subcommand, callback?): Promise<"OK">

  • Reloads the rules 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">

  • acl(subcommand, reset, callback?): Promise<unknown>

  • Lists recent security events generated due to ACL rules.

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

    Parameters

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

    Returns Promise<unknown>

  • acl(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • acl(subcommand, count, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • acl(subcommand, callback?): Promise<"OK">

  • Saves the effective 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">

  • acl(subcommand, username, callback?): Promise<"OK">

  • Creates and modifies an ACL user and its rules.

    • 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">

  • acl(...args): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • acl(...args): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • acl(subcommand, callback?): Promise<string[]>

  • Lists all ACL users.

    • 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[]>

  • acl(subcommand, callback?): Promise<string>

  • Returns the authenticated username of 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, username, command, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • aclBuffer(...args): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • aclBuffer(...args): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • aclBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • aclBuffer(subcommand, bits, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • aclBuffer(subcommand, username, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • aclBuffer(subcommand, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • aclBuffer(subcommand, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • aclBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

addBuiltinCommand

  • addBuiltinCommand(commandName): void

  • Create add builtin command

    Parameters

    • commandName: string

    Returns void

append

  • append(key, value, callback?): Promise<number>

  • Appends a string to the value of a key. Creates the key if it doesn't exist.

    • 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

    Returns Promise<number>

arcount

  • arcount(key, callback?): Promise<number>

  • Returns the number of non-empty elements in an array.

    • group: array
    • complexity: O(1)
    • since: 8.8.0

    Parameters

    Returns Promise<number>

ardel

  • ardel(...args): Promise<number>

  • Deletes elements at the specified indices in an array.

    • group: array
    • complexity: O(N) where N is the number of indices to delete
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, ...indices: (string | number)[], callback: Callback<number>]

    Returns Promise<number>

  • ardel(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...indices: (string | number)[]]

    Returns Promise<number>

ardelrange

  • ardelrange(...args): Promise<number>

  • Deletes elements in one or more ranges.

    • group: array
    • complexity: Proportional to the number of existing elements / slices touched, not to the numeric span of the requested ranges
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, ...ranges: (string | number)[], callback: Callback<number>]

    Returns Promise<number>

  • ardelrange(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...ranges: (string | number)[]]

    Returns Promise<number>

arget

  • arget(key, index, callback?): Promise<string>

  • Gets the value at an index in an array.

    • group: array
    • complexity: O(1)
    • since: 8.8.0

    Parameters

    Returns Promise<string>

argetBuffer

  • argetBuffer(key, index, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

argetrange

  • argetrange(key, start, end, callback?): Promise<string[]>

  • Gets values in a range of indices.

    • group: array
    • complexity: O(N) where N is the range length
    • since: 8.8.0

    Parameters

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

    Returns Promise<string[]>

argetrangeBuffer

  • argetrangeBuffer(key, start, end, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

argrep

  • argrep(key, start, end, predicate, value, callback): Promise<number[]>

  • Searches array elements in a range using textual predicates.

    • group: array
    • complexity: O(P * C) where P is the number of visited positions in touched slices and C is the cost of evaluating the predicates on one existing element.
    • since: 8.8.0

    Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • predicate: "MATCH" | "EXACT" | "GLOB" | "RE"
    • value: RedisValue
    • callback: Callback<number[]>

    Returns Promise<number[]>

  • argrep(...args): Promise<number[] | [index: number, value: string][]>

  • Parameters

    • Rest ...args: [key: RedisKey, start: string | number, end: string | number, predicate: "MATCH" | "EXACT" | "GLOB" | "RE", value: RedisValue, ...args: RedisValue[], callback: Callback<number[] | [index: number, value: string][]>]

    Returns Promise<number[] | [index: number, value: string][]>

  • argrep<T>(...args): Promise<"WITHVALUES" extends T[number]
        ? [index: number, value: string][]
        : number[]>

  • Type Parameters

    Parameters

    • Rest ...args: [key: RedisKey, start: string | number, end: string | number, predicate: "MATCH" | "EXACT" | "GLOB" | "RE", value: RedisValue, ...args: T[]]

    Returns Promise<"WITHVALUES" extends T[number]
        ? [index: number, value: string][]
        : number[]>

argrepBuffer

  • argrepBuffer(key, start, end, predicate, value, callback): Promise<number[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • predicate: "MATCH" | "EXACT" | "GLOB" | "RE"
    • value: RedisValue
    • callback: Callback<number[]>

    Returns Promise<number[]>

  • argrepBuffer(...args): Promise<number[] | [index: number, value: Buffer][]>

  • Parameters

    • Rest ...args: [key: RedisKey, start: string | number, end: string | number, predicate: "MATCH" | "EXACT" | "GLOB" | "RE", value: RedisValue, ...args: RedisValue[], callback: Callback<number[] | [index: number, value: Buffer][]>]

    Returns Promise<number[] | [index: number, value: Buffer][]>

  • argrepBuffer<T>(...args): Promise<"WITHVALUES" extends T[number]
        ? [index: number, value: Buffer][]
        : number[]>

  • Type Parameters

    Parameters

    • Rest ...args: [key: RedisKey, start: string | number, end: string | number, predicate: "MATCH" | "EXACT" | "GLOB" | "RE", value: RedisValue, ...args: T[]]

    Returns Promise<"WITHVALUES" extends T[number]
        ? [index: number, value: Buffer][]
        : number[]>

arinfo

  • arinfo(key, full, callback?): Promise<(string | number)[]>

  • Returns metadata about an array.

    • group: array
    • complexity: O(1), or O(N) with FULL option where N is the number of slices.
    • since: 8.8.0

    Parameters

    Returns Promise<(string | number)[]>

  • arinfo(key, callback?): Promise<(string | number)[]>

  • Parameters

    Returns Promise<(string | number)[]>

arinfoBuffer

  • arinfoBuffer(key, full, callback?): Promise<(number | Buffer)[]>

  • Parameters

    Returns Promise<(number | Buffer)[]>

  • arinfoBuffer(key, callback?): Promise<(number | Buffer)[]>

  • Parameters

    Returns Promise<(number | Buffer)[]>

arinsert

  • arinsert(...args): Promise<number>

  • Inserts one or more values at consecutive indices.

    • group: array
    • complexity: O(N) where N is the number of values
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, ...values: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • arinsert(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...values: (string | number | Buffer)[]]

    Returns Promise<number>

arlastitems

  • arlastitems(key, count, rev, callback?): Promise<string[]>

  • Returns the most recently inserted elements.

    • group: array
    • complexity: O(N) where N is the count
    • since: 8.8.0

    Parameters

    • key: RedisKey
    • count: string | number
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • arlastitems(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

arlastitemsBuffer

  • arlastitemsBuffer(key, count, rev, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • arlastitemsBuffer(key, count, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

arlen

  • arlen(key, callback?): Promise<number>

  • Returns the length of an array (max index + 1).

    • group: array
    • complexity: O(1)
    • since: 8.8.0

    Parameters

    Returns Promise<number>

armget

  • armget(...args): Promise<string[]>

  • Gets values at multiple indices in an array.

    • group: array
    • complexity: O(N) where N is the number of indices
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, ...indices: (string | number)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • armget(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...indices: (string | number)[]]

    Returns Promise<string[]>

armgetBuffer

  • armgetBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...indices: (string | number)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • armgetBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...indices: (string | number)[]]

    Returns Promise<Buffer[]>

armset

  • armset(...args): Promise<number>

  • Sets multiple index-value pairs in an array.

    • group: array
    • complexity: O(N) where N is the number of pairs
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • armset(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

arnext

  • arnext(key, callback?): Promise<number>

  • Returns the next index ARINSERT would use.

    • group: array
    • complexity: O(1)
    • since: 8.8.0

    Parameters

    Returns Promise<number>

arop

  • arop(key, start, end, sum, callback?): Promise<string>

  • Performs aggregate operations on array elements in a range.

    • group: array
    • complexity: O(P) where P is visited positions in touched slices (dense scanned slots + sparse entries), with worst-case O(|end-start|+1) and typical case close to O(N), where N is the number of existing elements in range.
    • since: 8.8.0

    Parameters

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

    Returns Promise<string>

  • arop(key, start, end, min, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • arop(key, start, end, max, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • arop(key, start, end, and, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • arop(key, start, end, or, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • arop(key, start, end, xor, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • arop(key, start, end, match, value, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • match: "MATCH"
    • value: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • arop(key, start, end, used, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

aropBuffer

  • aropBuffer(key, start, end, sum, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • sum: "SUM"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • aropBuffer(key, start, end, min, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • min: "MIN"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • aropBuffer(key, start, end, max, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • max: "MAX"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

arring

  • arring(...args): Promise<number>

  • Inserts values into a ring buffer of specified size, wrapping and truncating as needed.

    • group: array
    • complexity: O(M) normally, O(N+M) on ring resize, where N is the maximum of the old and new ring size and M is the number of inserted values
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, size: string | number, ...values: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • arring(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, size: string | number, ...values: (string | number | Buffer)[]]

    Returns Promise<number>

arscan

  • arscan(key, start, end, limitToken, limit, callback?): Promise<[index: number, value: string][]>

  • Iterates existing elements in a range, returning index-value pairs.

    • group: array
    • complexity: O(P) where P is visited positions in touched slices (dense scanned slots + sparse entries), with worst-case O(|end-start|+1) and typical case close to O(N), where N is the number of existing elements in range.
    • since: 8.8.0

    Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • limitToken: "LIMIT"
    • limit: string | number
    • Optional callback: Callback<[index: number, value: string][]>

    Returns Promise<[index: number, value: string][]>

  • arscan(key, start, end, callback?): Promise<[index: number, value: string][]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optional callback: Callback<[index: number, value: string][]>

    Returns Promise<[index: number, value: string][]>

arscanBuffer

  • arscanBuffer(key, start, end, limitToken, limit, callback?): Promise<[index: number, value: Buffer][]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • limitToken: "LIMIT"
    • limit: string | number
    • Optional callback: Callback<[index: number, value: Buffer][]>

    Returns Promise<[index: number, value: Buffer][]>

  • arscanBuffer(key, start, end, callback?): Promise<[index: number, value: Buffer][]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optional callback: Callback<[index: number, value: Buffer][]>

    Returns Promise<[index: number, value: Buffer][]>

arseek

  • arseek(key, index, callback?): Promise<number>

  • Sets the ARINSERT / ARRING cursor to a specific index.

    • group: array
    • complexity: O(1)
    • since: 8.8.0

    Parameters

    Returns Promise<number>

arset

  • arset(...args): Promise<number>

  • Sets one or more contiguous values starting at an index in an array.

    • group: array
    • complexity: O(N) where N is the number of values
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, index: string | number, ...values: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • arset(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, index: string | number, ...values: (string | number | Buffer)[]]

    Returns Promise<number>

asking

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

  • Signals that a cluster client is following an -ASK redirect.

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

    Parameters

    Returns Promise<"OK">

auth

  • auth(password, callback?): Promise<"OK">

  • Authenticates the connection.

    • 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">

  • auth(username, password, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

bgrewriteaof

  • bgrewriteaof(callback?): Promise<string>

  • Asynchronously rewrites the append-only file to disk.

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

    Parameters

    Returns Promise<string>

bgrewriteaofBuffer

  • bgrewriteaofBuffer(callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

bgsave

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

  • Asynchronously saves the database(s) to disk.

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

    Parameters

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

    Returns Promise<"OK">

  • bgsave(callback?): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

bitcount

  • bitcount(key, start, end, byte, callback?): Promise<number>

  • Counts the number of set bits (population counting) in a string.

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

    Parameters

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

    Returns Promise<number>

  • bitcount(key, start, end, bit, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • bitcount(key, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

  • bitcount(key, start, end, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

bitfield

  • bitfield(key, overflow, wrap, setBlockToken, encoding, offset, value, callback?): Promise<unknown>

  • Performs arbitrary bitfield integer operations on strings.

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

    Parameters

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

    Returns Promise<unknown>

  • bitfield(key, overflow, wrap, incrbyBlockToken, encoding, offset, increment, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, overflow, sat, setBlockToken, encoding, offset, value, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, overflow, sat, incrbyBlockToken, encoding, offset, increment, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, overflow, fail, setBlockToken, encoding, offset, value, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, overflow, fail, incrbyBlockToken, encoding, offset, increment, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, getBlockToken, encoding, offset, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, setBlockToken, encoding, offset, value, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, incrbyBlockToken, encoding, offset, increment, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bitfield(key, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

bitfield_ro

  • bitfield_ro(...args): Promise<unknown[]>

  • Performs arbitrary read-only bitfield integer operations on strings.

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

    Parameters

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

    Returns Promise<unknown[]>

  • bitfield_ro(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • bitfield_ro(key, callback?): Promise<unknown[]>

  • Parameters

    Returns Promise<unknown[]>

bitop

bitpos

  • bitpos(key, bit, start, end, byte, callback?): Promise<number>

  • Finds the first set (1) or clear (0) bit in a string.

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

    Parameters

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

    Returns Promise<number>

  • bitpos(key, bit, start, end, bit1, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • bitpos(key, bit, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

  • bitpos(key, bit, start, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • bitpos(key, bit, start, end, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

blmove

  • blmove(source, destination, left, left1, timeout, callback?): Promise<string>

  • Pops an element from a list, pushes it to another list and returns it. Blocks until an element is available otherwise. Deletes the list if the last element was moved.

    • 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>

  • blmove(source, destination, left, right, timeout, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • blmove(source, destination, right, left, timeout, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • blmove(source, destination, right, right1, timeout, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

blmoveBuffer

  • blmoveBuffer(source, destination, left, left1, timeout, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • blmoveBuffer(source, destination, left, right, timeout, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • blmoveBuffer(source, destination, right, left, timeout, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • blmoveBuffer(source, destination, right, right1, timeout, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

blmovem

  • blmovem(source, destination, left, left1, timeout, countToken, count, obo, callback?): Promise<string[]>

  • Moves up to (or exactly) a number of elements from one list to another and returns them. Blocks until the elements are available otherwise. Deletes the source list if it becomes empty.

    • group: list
    • complexity: O(N) where N is the number of elements moved.
    • since: 8.10.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, left1, timeout, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, left1, timeout, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, left1, timeout, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, right, timeout, countToken, count, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, right, timeout, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, right, timeout, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, right, timeout, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, left, timeout, countToken, count, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, left, timeout, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, left, timeout, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, left, timeout, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, right1, timeout, countToken, count, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, right1, timeout, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, right1, timeout, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, right, right1, timeout, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • blmovem(source, destination, left, left1, timeout, callback?): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • blmovem(source, destination, left, right, timeout, callback?): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • blmovem(source, destination, right, left, timeout, callback?): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • blmovem(source, destination, right, right1, timeout, callback?): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

blmovemBuffer

  • blmovemBuffer(source, destination, left, left1, timeout, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, left1, timeout, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, left1, timeout, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, left1, timeout, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, right, timeout, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, right, timeout, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, right, timeout, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, right, timeout, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, left, timeout, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, left, timeout, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, left, timeout, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, left, timeout, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, right1, timeout, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, right1, timeout, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, right1, timeout, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, right1, timeout, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, left1, timeout, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, left, right, timeout, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, left, timeout, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • blmovemBuffer(source, destination, right, right1, timeout, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

blmpop

  • blmpop(...args): Promise<[key: string, members: string[]]>

  • Pops the first element from one of multiple lists. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

    • 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", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

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

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

  • blmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

  • blmpop(...args): 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[]]>

  • blmpop(...args): 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[]]>

  • blmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

  • blmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

blmpopBuffer

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

  • blmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): 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[]]>

  • blmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

  • blmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

blpop

  • blpop(...args): Promise<[string, string]>

  • Removes and returns the first element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

    • 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]>

  • blpop(...args): Promise<[string, string]>

  • Parameters

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

    Returns Promise<[string, string]>

  • blpop(...args): Promise<[string, string]>

  • Parameters

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

    Returns Promise<[string, string]>

  • blpop(...args): Promise<[string, string]>

  • Parameters

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

    Returns Promise<[string, string]>

blpopBuffer

  • blpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

  • blpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

  • blpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

  • blpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

brpop

  • brpop(...args): Promise<[string, string]>

  • Removes and returns the last element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.

    • 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]>

  • brpop(...args): Promise<[string, string]>

  • Parameters

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

    Returns Promise<[string, string]>

  • brpop(...args): Promise<[string, string]>

  • Parameters

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

    Returns Promise<[string, string]>

  • brpop(...args): Promise<[string, string]>

  • Parameters

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

    Returns Promise<[string, string]>

brpopBuffer

  • brpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

  • brpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

  • brpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

  • brpopBuffer(...args): Promise<[Buffer, Buffer]>

  • Parameters

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

    Returns Promise<[Buffer, Buffer]>

brpoplpush

  • brpoplpush(source, destination, timeout, callback?): Promise<string>

  • Pops an element from a list, pushes it to another list and returns it. Block until an element is available otherwise. Deletes the list if the last element was popped.

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

    Parameters

    Returns Promise<string>

brpoplpushBuffer

  • brpoplpushBuffer(source, destination, timeout, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

bzmpop

  • bzmpop(...args): Promise<unknown>

  • Removes and returns a member by score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

    • group: sorted-set
    • complexity: O(K) + O(M*log(N)) 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", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • bzmpop(...args): 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>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): 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>

  • bzmpop(...args): 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>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • bzmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

bzpopmax

  • bzpopmax(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Removes and returns the member with the highest score from one or more sorted sets. Blocks until a member available otherwise. Deletes the sorted set if the last element was popped.

    • 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<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmax(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmax(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmax(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

bzpopmaxBuffer

  • bzpopmaxBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmaxBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmaxBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmaxBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

bzpopmin

  • bzpopmin(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Removes and returns the member with the lowest score from one or more sorted sets. Blocks until a member is available otherwise. Deletes the sorted set if the last element was popped.

    • 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<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmin(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmin(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopmin(...args): Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: string, member: string, score: string]>, Resp3<[key: string, member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

bzpopminBuffer

  • bzpopminBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopminBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [keys: RedisKey[], timeout: string | number, callback: Callback<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopminBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • bzpopminBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

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

    Returns Promise<RespShape<Resp2<[key: Buffer, member: Buffer, score: Buffer]>, Resp3<[key: Buffer, member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

call

  • call(command, callback?): 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>

  • call(command, args, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • call(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • call(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

callBuffer

  • callBuffer(command, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • callBuffer(command, args, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • callBuffer(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • callBuffer(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

client

  • client(subcommand, yes, callback?): Promise<"OK">

  • Instructs the server whether to track the 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">

  • client(subcommand, no, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • client(subcommand, callback?): Promise<string>

  • Returns the name of the connection.

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

    Parameters

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

    Returns Promise<string>

  • client(subcommand, callback?): Promise<number>

  • Returns the client ID to which the connection's tracking notifications are redirected.

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

    Parameters

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

    Returns Promise<number>

  • client(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • client(subcommand, callback?): Promise<number>

  • Returns the unique client ID of the connection.

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

    Parameters

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

    Returns Promise<number>

  • client(subcommand, callback?): Promise<string>

  • Returns information about the connection.

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

    Parameters

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

    Returns Promise<string>

  • client(subcommand, type, normal, callback?): Promise<unknown>

  • Terminates open connections.

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

    Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, master, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, slave, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • type: "TYPE"
    • slave: "SLAVE"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, type, replica, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, pubsub, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, skipme, yes, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • skipme: "SKIPME"
    • yes: "YES"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, skipme, no, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • skipme: "SKIPME"
    • no: "NO"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, clientIdToken, clientId, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • clientIdToken: "ID"
    • clientId: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, usernameToken, username, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • usernameToken: "USER"
    • username: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, addrToken, addr, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • addrToken: "ADDR"
    • addr: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, laddrToken, laddr, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • laddrToken: "LADDR"
    • laddr: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, maxageToken, maxage, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • maxageToken: "MAXAGE"
    • maxage: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, oldFormat, callback?): Promise<unknown>

  • Parameters

    • subcommand: "KILL"
    • oldFormat: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Lists open connections.

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

    Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, normal, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, master, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, replica, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, type, pubsub, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, on, callback?): Promise<unknown>

  • Sets the client eviction mode of the connection.

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

    Parameters

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

    Returns Promise<unknown>

  • client(subcommand, off, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, on, callback?): Promise<unknown>

  • Controls whether commands sent by the client affect the LRU/LFU of accessed keys.

    • group: connection
    • complexity: O(1)
    • since: 7.2.0

    Parameters

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

    Returns Promise<unknown>

  • client(subcommand, off, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, timeout, write, callback?): Promise<"OK">

  • Suspends commands processing.

    • group: connection
    • complexity: O(1)
    • since: 3.0.0

    Parameters

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

    Returns Promise<"OK">

  • client(subcommand, timeout, all, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • client(subcommand, timeout, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • client(subcommand, on, callback?): Promise<unknown>

  • Instructs 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>

  • client(subcommand, off, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, skip, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, libnameToken, libname, callback?): Promise<string>

  • Sets information specific to the client or connection.

    • group: connection
    • complexity: O(1)
    • since: 7.2.0

    Parameters

    • subcommand: "SETINFO"
    • libnameToken: "LIB-NAME"
    • libname: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • client(subcommand, libverToken, libver, callback?): Promise<string>

  • Parameters

    • subcommand: "SETINFO"
    • libverToken: "LIB-VER"
    • libver: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • client(subcommand, connectionName, callback?): Promise<"OK">

  • Sets the connection name.

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

    Parameters

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

    Returns Promise<"OK">

  • client(...args): Promise<unknown>

  • Controls server-assisted client-side caching for the connection.

    • 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>

  • client(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<string>

  • Returns information about server-assisted client-side caching for the connection.

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

    Parameters

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

    Returns Promise<string>

  • client(subcommand, clientId, timeout, callback?): Promise<unknown>

  • Unblocks a client blocked by 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
    • timeout: "TIMEOUT"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • client(subcommand, clientId, error, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, clientId, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • client(subcommand, callback?): Promise<"OK">

  • Resumes processing commands from paused clients.

    • 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, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • clientBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • clientBuffer(subcommand, libnameToken, libname, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "SETINFO"
    • libnameToken: "LIB-NAME"
    • libname: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • clientBuffer(subcommand, libverToken, libver, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "SETINFO"
    • libverToken: "LIB-VER"
    • libver: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • clientBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

cluster

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Assigns new hash slots to a 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[]][]][]>

  • cluster(...args): 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[]][]][]>

  • cluster(...args): 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[]][]][]>

  • cluster(...args): 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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Assigns new hash slot ranges to a 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", ...ranges: (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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

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

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

  • cluster(subcommand, callback?): Promise<"BUMPED" | "STILL">

  • Advances 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">

  • cluster(subcommand, nodeId, callback?): Promise<number>

  • Returns the number of active failure reports active for a 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>

  • cluster(subcommand, slot, callback?): Promise<number>

  • Returns the number of keys in a hash slot.

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

    Parameters

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

    Returns Promise<number>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Sets hash slots as unbound for a 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[]][]][]>

  • cluster(...args): 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[]][]][]>

  • cluster(...args): 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[]][]][]>

  • cluster(...args): 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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Sets hash slot ranges as unbound for a 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", ...ranges: (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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

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

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

  • cluster(subcommand, force, callback?): Promise<"OK">

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

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

    Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, takeover, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Deletes all slots information from a node.

    • 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[]][]][]>

  • cluster(subcommand, nodeId, callback?): Promise<"OK">

  • Removes 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">

  • cluster(subcommand, slot, count, callback?): Promise<string[]>

  • Returns the key names in a hash slot.

    • group: cluster
    • complexity: O(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[]>

  • cluster(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • cluster(subcommand, callback?): Promise<string>

  • Returns information about the state of a node.

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

    Parameters

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

    Returns Promise<string>

  • cluster(subcommand, key, callback?): Promise<number>

  • Returns the hash slot for a 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>

  • cluster(subcommand, callback?): Promise<unknown[]>

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

    • 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[]>

  • cluster(subcommand, ip, port, callback?): Promise<"OK">

  • Forces a node 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">

  • cluster(subcommand, ip, port, clusterBusPort, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, cancel, taskIdToken, taskId, callback?): Promise<unknown>

  • Start, monitor and cancel slot migration.

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

    Parameters

    • subcommand: "MIGRATION"
    • cancel: "CANCEL"
    • taskIdToken: "ID"
    • taskId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, cancel, all, callback?): Promise<unknown>

  • Parameters

    • subcommand: "MIGRATION"
    • cancel: "CANCEL"
    • all: "ALL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, status, taskIdToken, taskId, callback?): Promise<unknown>

  • Parameters

    • subcommand: "MIGRATION"
    • status: "STATUS"
    • taskIdToken: "ID"
    • taskId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, status, all, callback?): Promise<unknown>

  • Parameters

    • subcommand: "MIGRATION"
    • status: "STATUS"
    • all: "ALL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "MIGRATION", importToken: "IMPORT", ...imports: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • cluster(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "MIGRATION", importToken: "IMPORT", ...imports: (string | number)[]]

    Returns Promise<unknown>

  • cluster(subcommand, status, callback?): Promise<unknown>

  • Parameters

    • subcommand: "MIGRATION"
    • status: "STATUS"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, status, callback?): Promise<unknown>

  • Parameters

    • subcommand: "MIGRATION"
    • status: "STATUS"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, callback?): Promise<string>

  • Returns the ID of a node.

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

    Parameters

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

    Returns Promise<string>

  • cluster(subcommand, callback?): Promise<unknown>

  • Returns the shard ID of a node.

    • group: cluster
    • complexity: O(1)
    • since: 7.2.0

    Parameters

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

    Returns Promise<unknown>

  • cluster(subcommand, callback?): Promise<unknown>

  • Returns the cluster configuration for a 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>

  • cluster(subcommand, nodeId, callback?): Promise<unknown>

  • Lists the replica nodes of a master node.

    • group: cluster
    • complexity: O(N) where N is the number of replicas.
    • since: 5.0.0

    Parameters

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

    Returns Promise<unknown>

  • cluster(subcommand, nodeId, callback?): Promise<"OK">

  • Configure a node as replica of a 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">

  • cluster(subcommand, hard, callback?): Promise<"OK">

  • Resets a 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"
    • hard: "HARD"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • cluster(subcommand, soft, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, callback?): Promise<"OK">

  • Forces a node to save the cluster configuration to disk.

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

    Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, configEpoch, callback?): Promise<"OK">

  • Sets the configuration epoch for 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">

  • cluster(subcommand, slot, importingToken, importing, callback?): Promise<"OK">

  • Binds a hash slot to a node.

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

    Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, slot, migratingToken, migrating, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, slot, nodeToken, node, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, slot, stable, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • cluster(subcommand, callback?): Promise<unknown>

  • Returns the mapping of cluster slots to shards.

    • 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>

  • cluster(subcommand, nodeId, callback?): Promise<unknown>

  • Lists the replica nodes of a master node.

    • group: cluster
    • complexity: O(N) where N is the number of replicas.
    • since: 3.0.0

    Parameters

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

    Returns Promise<unknown>

  • cluster(subcommand, orderbyToken, metric, limitToken, limit, asc, callback?): Promise<unknown>

  • Return an array of slot usage statistics for slots assigned to the current node.

    • group: cluster
    • complexity: O(N) where N is the total number of slots based on arguments. O(N*log(N)) with ORDERBY subcommand.
    • since: 8.2.0

    Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • limitToken: "LIMIT"
    • limit: string | number
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, orderbyToken, metric, limitToken, limit, desc, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • limitToken: "LIMIT"
    • limit: string | number
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, orderbyToken, metric, asc, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, orderbyToken, metric, desc, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, orderbyToken, metric, limitToken, limit, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • limitToken: "LIMIT"
    • limit: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, slotsrangeToken, startSlot, endSlot, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SLOT-STATS"
    • slotsrangeToken: "SLOTSRANGE"
    • startSlot: string | number
    • endSlot: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, orderbyToken, metric, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SLOT-STATS"
    • orderbyToken: "ORDERBY"
    • metric: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • cluster(subcommand, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Returns the mapping of cluster slots to nodes.

    • 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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Internal command for atomic slot migration protocol between cluster nodes.

    • group: cluster
    • complexity: O(1)
    • since: 8.4.0

    Parameters

    • Rest ...args: [subcommand: "SYNCSLOTS", syncToken: "SYNC", taskId: string | number | Buffer, ...slotRanges: (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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "SYNCSLOTS", syncToken: "SYNC", taskId: string | number | Buffer, ...slotRanges: (string | number)[]]

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

  • cluster(subcommand, taskIdToken, taskId, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • subcommand: "SYNCSLOTS"
    • taskIdToken: "RDBCHANNEL"
    • taskId: string | number | Buffer
    • 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[]][]][]>

  • cluster(subcommand, snapshotEof, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • subcommand: "SYNCSLOTS"
    • snapshotEof: "SNAPSHOT-EOF"
    • 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[]][]][]>

  • cluster(subcommand, streamEof, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • subcommand: "SYNCSLOTS"
    • streamEof: "STREAM-EOF"
    • 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[]][]][]>

  • cluster(subcommand, ackToken, state, offset, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • subcommand: "SYNCSLOTS"
    • ackToken: "ACK"
    • state: string | Buffer
    • offset: string | number
    • 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[]][]][]>

  • cluster(subcommand, errorToken, error, callback?): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • subcommand: "SYNCSLOTS"
    • errorToken: "FAIL"
    • error: string | Buffer
    • 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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "SYNCSLOTS", confToken: "CONF", ...args: RedisValue[], 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[]][]][]>

  • cluster(...args): Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest ...args: [subcommand: "SYNCSLOTS", confToken: "CONF", ...args: RedisValue[]]

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

command

  • command(subcommand, callback?): Promise<unknown[]>

  • Returns a count of commands.

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

    Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, callback?): Promise<unknown[]>

  • Returns documentary information about one, multiple or all commands.

    • 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[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, command, callback?): Promise<unknown[]>

  • Extracts the key names from an arbitrary command.

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

    Parameters

    • subcommand: "GETKEYS"
    • command: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, command, callback?): Promise<unknown[]>

  • Extracts the key names and access flags for an arbitrary command.

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

    Parameters

    • subcommand: "GETKEYSANDFLAGS"
    • command: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, callback?): Promise<unknown[]>

  • Returns 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[]>

  • command(subcommand, callback?): Promise<unknown[]>

  • Returns information about one, multiple or all commands.

    • 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[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, filterby, moduleNameToken, moduleName, callback?): Promise<unknown[]>

  • Returns a list of command names.

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

    Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, filterby, categoryToken, category, callback?): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, filterby, patternToken, pattern, callback?): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • command(subcommand, callback?): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

config

  • config(...args): Promise<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the effective 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<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • config(...args): Promise<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<Resp3Map<string>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • config(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • config(subcommand, callback?): Promise<unknown>

  • Resets the server's statistics.

    • group: server
    • complexity: O(1)
    • since: 2.0.0

    Parameters

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

    Returns Promise<unknown>

  • config(subcommand, callback?): Promise<unknown>

  • Persists the effective configuration to file.

    • group: server
    • complexity: O(1)
    • since: 2.8.0

    Parameters

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

    Returns Promise<unknown>

  • config(...args): Promise<unknown>

  • Sets configuration parameters in-flight.

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0

    Parameters

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

    Returns Promise<unknown>

  • config(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "SET", ...data: (string | number | Buffer)[]]

    Returns Promise<unknown>

configBuffer

  • configBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • configBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<Resp3Map<Buffer>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

connect

  • connect(callback?): 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. The promise can reject if the connection fails, times out, or if Redis is already connecting/connected.

    Parameters

    Returns Promise<void>

copy

  • copy(source, destination, destinationDbToken, destinationDb, replace, callback?): Promise<number>

  • Copies the value of a key to a new 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

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • copy(source, destination, replace, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

  • copy(source, destination, destinationDbToken, destinationDb, callback?): Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • copy(source, destination, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

createBuiltinCommand

  • createBuiltinCommand(commandName): {
        buffer: any;
        string: any;
    }

  • Create a builtin command

    Parameters

    • commandName: string

    Returns {
        buffer: any;
        string: any;
    }

    • buffer: any
    • string: any

dbsize

  • dbsize(callback?): Promise<number>

  • Returns the number of keys in the database.

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

    Parameters

    Returns Promise<number>

debug

  • debug(subcommand, callback?): 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>

  • debug(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • debug(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

decr

  • decr(key, callback?): Promise<number>

  • Decrements the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

decrby

  • decrby(key, decrement, callback?): Promise<number>

  • Decrements a number from the integer value of a key. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

defineCommand

  • defineCommand(name, definition): 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): Promise<number>

  • Deletes one or more keys.

    • 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

    Returns Promise<number>

  • del(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • del(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • del(...args): Promise<number>

  • Parameters

    Returns Promise<number>

discard

  • discard(callback?): Promise<"OK">

  • Discards a transaction.

    • group: transactions
    • complexity: O(N), when N is the number of queued commands
    • since: 2.0.0

    Parameters

    Returns Promise<"OK">

disconnect

  • disconnect(reconnect?): 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, callback?): Promise<string>

  • Returns a serialized representation of the value stored at a 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

    Returns Promise<string>

dumpBuffer

duplicate

echo

  • echo(message, callback?): Promise<string>

  • Returns 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, callback?): Promise<Buffer>

  • Parameters

    • message: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

end

  • end(): void

  • Disconnect from Redis.

    Returns void

    Deprecated

eval

  • eval(script, numkeys, callback?): Promise<unknown>

  • Executes a server-side Lua script.

    • 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>

  • eval(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • eval(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

eval_ro

  • eval_ro(script, numkeys, callback?): Promise<unknown>

  • Executes a read-only server-side Lua script.

    • group: scripting
    • complexity: Depends on the script that is executed.
    • since: 7.0.0

    Parameters

    • script: string | Buffer
    • numkeys: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • eval_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

evalsha

  • evalsha(sha1, numkeys, callback?): Promise<unknown>

  • Executes a server-side Lua script by SHA1 digest.

    • 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>

  • evalsha(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • evalsha(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

evalsha_ro

  • evalsha_ro(sha1, numkeys, callback?): Promise<unknown>

  • Executes a read-only server-side Lua script by SHA1 digest.

    • group: scripting
    • complexity: Depends on the script that is executed.
    • since: 7.0.0

    Parameters

    • sha1: string | Buffer
    • numkeys: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • evalsha_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

exec

  • exec(callback?): Promise<[error: Error, result: unknown][]>

  • Executes all commands in a transaction.

    • 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): Promise<number>

  • Determines whether one or more keys exist.

    • group: generic
    • complexity: O(N) where N is the number of keys to check.
    • since: 1.0.0

    Parameters

    Returns Promise<number>

  • exists(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • exists(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • exists(...args): Promise<number>

  • Parameters

    Returns Promise<number>

expire

  • expire(key, seconds, nx, callback?): Promise<number>

  • Sets the expiration time of a key in seconds.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • seconds: string | number
    • nx: "NX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expire(key, seconds, xx, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • xx: "XX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expire(key, seconds, gt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • gt: "GT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expire(key, seconds, lt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • lt: "LT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expire(key, seconds, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

expireat

  • expireat(key, unixTimeSeconds, nx, callback?): Promise<number>

  • Sets the expiration time of a key to a Unix timestamp.

    • group: generic
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • nx: "NX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expireat(key, unixTimeSeconds, xx, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • xx: "XX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expireat(key, unixTimeSeconds, gt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • gt: "GT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expireat(key, unixTimeSeconds, lt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • lt: "LT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • expireat(key, unixTimeSeconds, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

expiretime

  • expiretime(key, callback?): Promise<number>

  • Returns the expiration time of a key as a Unix timestamp.

    • group: generic
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    Returns Promise<number>

failover

  • failover(targetToken, host, port, force, abort, millisecondsToken, milliseconds, callback?): Promise<"OK">

  • Starts a coordinated failover from a server to one of its replicas.

    • group: server
    • complexity: O(1)
    • since: 6.2.0

    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">

  • failover(targetToken, host, port, abort, millisecondsToken, milliseconds, callback?): 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">

  • failover(targetToken, host, port, force, millisecondsToken, milliseconds, callback?): 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">

  • failover(targetToken, host, port, force, abort, callback?): Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(abort, millisecondsToken, milliseconds, callback?): Promise<"OK">

  • Parameters

    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(targetToken, host, port, millisecondsToken, milliseconds, callback?): Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(targetToken, host, port, abort, callback?): Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(targetToken, host, port, force, callback?): Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(millisecondsToken, milliseconds, callback?): Promise<"OK">

  • Parameters

    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(abort, callback?): Promise<"OK">

  • Parameters

    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(targetToken, host, port, callback?): Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • failover(callback?): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

fcall

  • fcall(func, numkeys, callback?): Promise<unknown>

  • Invokes a function.

    • group: scripting
    • complexity: Depends on the function that is executed.
    • since: 7.0.0

    Parameters

    • func: string | Buffer
    • numkeys: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • fcall(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

fcall_ro

  • fcall_ro(func, numkeys, callback?): Promise<unknown>

  • Invokes a read-only function.

    • group: scripting
    • complexity: Depends on the function that is executed.
    • since: 7.0.0

    Parameters

    • func: string | Buffer
    • numkeys: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • fcall_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [func: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

flushall

  • flushall(async, callback?): Promise<"OK">

  • Removes 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

    • async: "ASYNC"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • flushall(sync, callback?): Promise<"OK">

  • Parameters

    • sync: "SYNC"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • flushall(callback?): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

flushdb

  • flushdb(async, callback?): 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

    • async: "ASYNC"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • flushdb(sync, callback?): Promise<"OK">

  • Parameters

    • sync: "SYNC"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • flushdb(callback?): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

function

  • function(subcommand, libraryName, callback?): Promise<string>

  • Deletes a library and its functions.

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "DELETE"
    • libraryName: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, callback?): Promise<string>

  • Dumps all libraries 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>

  • function(subcommand, async, callback?): Promise<string>

  • Deletes all libraries and functions.

    • group: scripting
    • complexity: O(N) where N is the number of functions deleted
    • since: 7.0.0

    Parameters

    • subcommand: "FLUSH"
    • async: "ASYNC"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, sync, callback?): Promise<string>

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • function(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • function(subcommand, callback?): Promise<string>

  • Terminates a function during execution.

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

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

    Returns Promise<string>

  • function(subcommand, libraryNamePatternToken, libraryNamePattern, withcode, callback?): Promise<unknown[]>

  • Returns information about all libraries.

    • group: scripting
    • complexity: O(N) where N is the number of functions
    • since: 7.0.0

    Parameters

    • subcommand: "LIST"
    • libraryNamePatternToken: "LIBRARYNAME"
    • libraryNamePattern: string | Buffer
    • withcode: "WITHCODE"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • function(subcommand, withcode, callback?): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • function(subcommand, libraryNamePatternToken, libraryNamePattern, callback?): Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • libraryNamePatternToken: "LIBRARYNAME"
    • libraryNamePattern: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • function(subcommand, callback?): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • function(subcommand, replace, functionCode, callback?): Promise<string>

  • Creates a library.

    • group: scripting
    • complexity: O(1) (considering compilation time is redundant)
    • since: 7.0.0

    Parameters

    • subcommand: "LOAD"
    • replace: "REPLACE"
    • functionCode: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, functionCode, callback?): Promise<string>

  • Parameters

    • subcommand: "LOAD"
    • functionCode: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, serializedValue, flush, callback?): Promise<string>

  • Restores all libraries from a 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
    • flush: "FLUSH"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, serializedValue, append, callback?): Promise<string>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • append: "APPEND"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, serializedValue, replace, callback?): Promise<string>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, serializedValue, callback?): Promise<string>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • function(subcommand, callback?): Promise<unknown>

  • Returns information about a function during execution.

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

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

    Returns Promise<unknown>

functionBuffer

  • functionBuffer(subcommand, libraryName, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "DELETE"
    • libraryName: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • functionBuffer(subcommand, async, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "FLUSH"
    • async: "ASYNC"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, sync, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • functionBuffer(subcommand, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

  • functionBuffer(subcommand, replace, functionCode, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "LOAD"
    • replace: "REPLACE"
    • functionCode: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, functionCode, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "LOAD"
    • functionCode: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, serializedValue, flush, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • flush: "FLUSH"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, serializedValue, append, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • append: "APPEND"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, serializedValue, replace, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • functionBuffer(subcommand, serializedValue, callback?): Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

geoadd

  • geoadd(...args): Promise<number>

  • Adds one or more members to a geospatial index. The key is created if it doesn't exist.

    • 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, nx: "NX", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • geoadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

geodist

  • geodist(key, member1, member2, m, callback?): Promise<string>

  • Returns the distance between two members of a geospatial index.

    • group: geo
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • m: "M"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • geodist(key, member1, member2, km, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • km: "KM"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • geodist(key, member1, member2, ft, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • ft: "FT"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • geodist(key, member1, member2, mi, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • mi: "MI"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • geodist(key, member1, member2, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

geodistBuffer

  • geodistBuffer(key, member1, member2, m, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • m: "M"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • geodistBuffer(key, member1, member2, km, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • km: "KM"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • geodistBuffer(key, member1, member2, ft, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • ft: "FT"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • geodistBuffer(key, member1, member2, mi, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • mi: "MI"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • geodistBuffer(key, member1, member2, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

geohash

  • geohash(key, callback?): Promise<string[]>

  • Returns members from a geospatial index as geohash strings.

    • group: geo
    • complexity: O(1) for each member requested.
    • since: 3.2.0

    Parameters

    Returns Promise<string[]>

  • geohash(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • geohash(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • geohash(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<string[]>

  • geohash(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<string[]>

geohashBuffer

  • geohashBuffer(key, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

  • geohashBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • geohashBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • geohashBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<Buffer[]>

  • geohashBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<Buffer[]>

geopos

  • geopos(key, callback?): Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the longitude and latitude of members from a geospatial index.

    • group: geo
    • complexity: O(1) for each member requested.
    • since: 3.2.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • geopos(...args): Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • geopos(...args): Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • geopos(...args): Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • geopos(...args): Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<[longitude: string, latitude: string][]>, Resp3<[longitude: number, latitude: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

georadius

  • georadius(...args): Promise<unknown[]>

  • Queries a geospatial index for members within a distance from a coordinate, optionally stores the result.

    • 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[]>

  • georadius(...args): 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): Promise<unknown>

  • Returns members from a geospatial index that are within a distance from a coordinate.

    • 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>

  • georadius_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

georadiusbymember

  • georadiusbymember(...args): Promise<unknown>

  • Queries a geospatial index for members within a distance from a member, optionally stores the result.

    • 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>

  • georadiusbymember(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

georadiusbymember_ro

  • georadiusbymember_ro(...args): Promise<unknown>

  • Returns members from a geospatial index that are within a 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.10

    Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • georadiusbymember_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

geosearch

  • geosearch(...args): Promise<unknown[]>

  • Queries a geospatial index for 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[]>

  • geosearch(...args): Promise<unknown[]>

  • Parameters

    Returns Promise<unknown[]>

geosearchstore

  • geosearchstore(...args): Promise<number>

  • Queries a geospatial index for members inside an area of a box or a circle, optionally stores the result.

    • 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>

  • geosearchstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

get

  • get(key, callback?): Promise<string>

  • Returns the string value of a key.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<string>

getBuffer

getBuiltinCommands

  • getBuiltinCommands(): string[]

  • Return supported builtin commands

    Returns string[]

getbit

  • getbit(key, offset, callback?): Promise<number>

  • Returns a bit value by offset.

    • group: bitmap
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    Returns Promise<number>

getdel

  • getdel(key, callback?): Promise<string>

  • Returns the string value of a key after deleting the key.

    • group: string
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    Returns Promise<string>

getdelBuffer

getex

  • getex(key, secondsToken, seconds, callback?): Promise<string>

  • Returns the string value of a key after setting its expiration time.

    • group: string
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • secondsToken: "EX"
    • seconds: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • getex(key, millisecondsToken, milliseconds, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • getex(key, unixTimeSecondsToken, unixTimeSeconds, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • getex(key, unixTimeMillisecondsToken, unixTimeMilliseconds, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • getex(key, persist, callback?): Promise<string>

  • Parameters

    Returns Promise<string>

  • getex(key, callback?): Promise<string>

  • Parameters

    Returns Promise<string>

getexBuffer

  • getexBuffer(key, secondsToken, seconds, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • secondsToken: "EX"
    • seconds: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • getexBuffer(key, millisecondsToken, milliseconds, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • getexBuffer(key, unixTimeSecondsToken, unixTimeSeconds, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • getexBuffer(key, unixTimeMillisecondsToken, unixTimeMilliseconds, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • getexBuffer(key, persist, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • getexBuffer(key, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

getrange

  • getrange(key, start, end, callback?): Promise<string>

  • Returns 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, start, end, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

getset

  • getset(key, value, callback?): Promise<string>

  • Returns the previous string value of a key after setting it to a new value.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<string>

getsetBuffer

  • getsetBuffer(key, value, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

hdel

  • hdel(...args): Promise<number>

  • Deletes one or more fields and their values from a hash. Deletes the hash if no fields remain.

    • 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>

  • hdel(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns Promise<number>

hello

  • hello(protover, authToken, username, password, clientnameToken, clientname, callback?): Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Handshakes with the Redis server.

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

    Parameters

    • protover: string | number
    • authToken: "AUTH"
    • username: string | Buffer
    • password: string | Buffer
    • clientnameToken: "SETNAME"
    • clientname: string | Buffer
    • Optional callback: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • hello(protover, clientnameToken, clientname, callback?): Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • protover: string | number
    • clientnameToken: "SETNAME"
    • clientname: string | Buffer
    • Optional callback: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • hello(protover, authToken, username, password, callback?): Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • protover: string | number
    • authToken: "AUTH"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • hello(callback?): Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Optional callback: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • hello(protover, callback?): Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • protover: string | number
    • Optional callback: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

hexists

  • hexists(key, field, callback?): Promise<number>

  • Determines whether a field exists in a hash.

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    Returns Promise<number>

hexpire

  • hexpire(...args): Promise<number[]>

  • Set expiry for hash field using relative time to expire (seconds)

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hexpireat

  • hexpireat(...args): Promise<number[]>

  • Set expiry for hash field using an absolute Unix timestamp (seconds)

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hexpiretime

  • hexpiretime(...args): Promise<number[]>

  • Returns the expiration time of a hash field as a Unix timestamp, in seconds.

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hexpiretime(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hget

  • hget(key, field, callback?): Promise<string>

  • Returns the value of a field in a hash.

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    Returns Promise<string>

hgetBuffer

  • hgetBuffer(key, field, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

hgetall

  • hgetall(key, callback?): Promise<Record<string, string>>

  • Returns all fields and values in a hash.

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    Returns Promise<Record<string, string>>

hgetallBuffer

  • hgetallBuffer(key, callback?): Promise<Record<string, Buffer>>

  • Parameters

    Returns Promise<Record<string, Buffer>>

hgetdel

  • hgetdel(...args): Promise<string[]>

  • Returns the value of a field and deletes it from the hash.

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 8.0.0

    Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetdel(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

hgetdelBuffer

  • hgetdelBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetdelBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

hgetex

  • hgetex(...args): Promise<string[]>

  • Get the value of one or more fields of a given hash key, and optionally set their expiration.

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 8.0.0

    Parameters

    • Rest ...args: [key: RedisKey, secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • hgetex(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

hgetexBuffer

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, persist: "PERSIST", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hgetexBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

himport

  • himport(subcommand, fieldsetName, callback?): Promise<number>

  • Removes a single session-local fieldset by name.

    • group: hash
    • complexity: O(N) where N is the number of session-local fieldsets.
    • since: 8.10.0

    Parameters

    • subcommand: "DISCARD"
    • fieldsetName: string | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • himport(subcommand, callback?): Promise<number>

  • Removes all session-local fieldsets for the connection.

    • group: hash
    • complexity: O(N) where N is the number of session-local fieldsets.
    • since: 8.10.0

    Parameters

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

    Returns Promise<number>

  • himport(...args): Promise<"OK">

  • Defines a session-local fieldset that maps a name to a sorted set of field names.

    • group: hash
    • complexity: O(N*log(N)) where N is the number of fields.
    • since: 8.10.0

    Parameters

    • Rest ...args: [subcommand: "PREPARE", fieldsetName: string | Buffer, ...fields: (string | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • himport(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [subcommand: "PREPARE", fieldsetName: string | Buffer, ...fields: (string | Buffer)[]]

    Returns Promise<"OK">

  • himport(...args): Promise<"OK">

  • Creates a fieldset-based hash from values supplied in the order matching a previously prepared fieldset.

    • group: hash
    • complexity: O(N) where N is the number of fields in the fieldset.
    • since: 8.10.0

    Parameters

    • Rest ...args: [subcommand: "SET", key: RedisKey, fieldsetName: string | Buffer, ...values: (string | number | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • himport(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [subcommand: "SET", key: RedisKey, fieldsetName: string | Buffer, ...values: (string | number | Buffer)[]]

    Returns Promise<"OK">

hincrby

  • hincrby(key, field, increment, callback?): Promise<number>

  • Increments the integer value of a field in a hash by a number. Uses 0 as initial value if the field doesn't exist.

    • 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, field, increment, callback?): Promise<string>

  • Increments the floating point value of a field by a number. Uses 0 as initial value if the field doesn't exist.

    • 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, field, increment, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

hkeys

  • hkeys(key, callback?): Promise<string[]>

  • Returns all fields in a hash.

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    Returns Promise<string[]>

hkeysBuffer

hlen

  • hlen(key, callback?): Promise<number>

  • Returns the number of fields in a hash.

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    Returns Promise<number>

hmget

  • hmget(...args): Promise<string[]>

  • Returns the values of all fields in a hash.

    • 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[]>

  • hmget(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns Promise<string[]>

hmgetBuffer

  • hmgetBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • hmgetBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns Promise<Buffer[]>

hmset

  • hmset(key, object, callback?): Promise<"OK">

  • Sets the values of multiple fields.

    • group: hash
    • complexity: O(N) where N is the number of fields being set.
    • since: 2.0.0

    Parameters

    Returns Promise<"OK">

  • hmset(key, map, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • hmset(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • hmset(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[]]

    Returns Promise<"OK">

hpersist

  • hpersist(...args): Promise<number[]>

  • Removes the expiration time for each specified field

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpersist(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hpexpire

  • hpexpire(...args): Promise<number[]>

  • Set expiry for hash field using relative time to expire (milliseconds)

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpire(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hpexpireat

  • hpexpireat(...args): Promise<number[]>

  • Set expiry for hash field using an absolute Unix timestamp (milliseconds)

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, nx: "NX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, xx: "XX", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, gt: "GT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, lt: "LT", fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpireat(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hpexpiretime

  • hpexpiretime(...args): Promise<number[]>

  • Returns the expiration time of a hash field as a Unix timestamp, in msec.

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpexpiretime(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hpttl

  • hpttl(...args): Promise<number[]>

  • Returns the TTL in milliseconds of a hash field.

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • hpttl(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hrandfield

  • hrandfield(key, count, withvalues, callback?): Promise<string | unknown[]>

  • Returns one or more 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
    • count: string | number
    • withvalues: "WITHVALUES"
    • Optional callback: Callback<string | unknown[]>

    Returns Promise<string | unknown[]>

  • hrandfield(key, callback?): Promise<string | unknown[]>

  • Parameters

    Returns Promise<string | unknown[]>

  • hrandfield(key, count, callback?): Promise<string | unknown[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<string | unknown[]>

    Returns Promise<string | unknown[]>

hrandfieldBuffer

  • hrandfieldBuffer(key, count, withvalues, callback?): Promise<unknown[] | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • withvalues: "WITHVALUES"
    • Optional callback: Callback<unknown[] | Buffer>

    Returns Promise<unknown[] | Buffer>

  • hrandfieldBuffer(key, callback?): Promise<unknown[] | Buffer>

  • Parameters

    Returns Promise<unknown[] | Buffer>

  • hrandfieldBuffer(key, count, callback?): Promise<unknown[] | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<unknown[] | Buffer>

    Returns Promise<unknown[] | Buffer>

hscan

  • hscan(key, cursor, patternToken, pattern, countToken, count, novalues, callback?): Promise<[cursor: string, elements: string[]]>

  • Iterates over fields and values of a hash.

    • 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
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • hscan(key, cursor, countToken, count, novalues, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • hscan(key, cursor, patternToken, pattern, novalues, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • hscan(key, cursor, patternToken, pattern, countToken, count, callback?): 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[]]>

  • hscan(key, cursor, novalues, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • hscan(key, cursor, countToken, count, callback?): 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[]]>

  • hscan(key, cursor, patternToken, pattern, callback?): 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[]]>

  • hscan(key, cursor, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

hscanBuffer

  • hscanBuffer(key, cursor, patternToken, pattern, countToken, count, novalues, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • hscanBuffer(key, cursor, countToken, count, novalues, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • hscanBuffer(key, cursor, patternToken, pattern, novalues, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • hscanBuffer(key, cursor, patternToken, pattern, countToken, count, callback?): 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[]]>

  • hscanBuffer(key, cursor, novalues, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • novalues: "NOVALUES"
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • hscanBuffer(key, cursor, countToken, count, callback?): 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[]]>

  • hscanBuffer(key, cursor, patternToken, pattern, callback?): 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[]]>

  • hscanBuffer(key, cursor, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

hscanBufferStream

hscanStream

hset

  • hset(key, object, callback?): Promise<number>

  • Creates or modifies the value of a field in a hash.

    • 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

    Returns Promise<number>

  • hset(key, map, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optional callback: Callback<number>

    Returns Promise<number>

  • hset(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hset(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

hsetex

  • hsetex(...args): Promise<number>

  • Set the value of one or more fields of a given hash key, and optionally set their expiration.

    • group: hash
    • complexity: O(N) where N is the number of fields being set.
    • since: 8.0.0

    Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, secondsToken: "EX", seconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, millisecondsToken: "PX", milliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, keepttl: "KEEPTTL", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fnx: "FNX", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fxx: "FXX", fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • hsetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

hsetnx

  • hsetnx(key, field, value, callback?): Promise<number>

  • Sets the value of a field in a hash only when the field doesn't 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, field, callback?): Promise<number>

  • Returns the length of the value of a field.

    • group: hash
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    Returns Promise<number>

httl

  • httl(...args): Promise<number[]>

  • Returns the TTL in seconds of a hash field.

    • group: hash
    • complexity: O(N) where N is the number of specified fields
    • since: 7.4.0

    Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • httl(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, fieldsToken: "FIELDS", numfields: string | number, ...fields: (string | Buffer)[]]

    Returns Promise<number[]>

hvals

  • hvals(key, callback?): Promise<string[]>

  • Returns all values in a hash.

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    Returns Promise<string[]>

hvalsBuffer

incr

  • incr(key, callback?): Promise<number>

  • Increments the integer value of a key by one. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

incrby

  • incrby(key, increment, callback?): Promise<number>

  • Increments the integer value of a key by a number. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

incrbyfloat

  • incrbyfloat(key, increment, callback?): Promise<string>

  • Increment the floating point value of a key by a number. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    Returns Promise<string>

increx

  • increx(...args): Promise<RespShape<Resp2<[value: number, increment: number] | [value: string, increment: string]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Increments the numeric value of a key by a number and sets its expiration time. Uses 0 as initial value if the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<RespShape<Resp2<[value: number, increment: number] | [value: string, increment: string]>, Resp3<[value: number, increment: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[value: number, increment: number] | [value: string, increment: string]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • increx(...args): Promise<RespShape<Resp2<[value: number, increment: number] | [value: string, increment: string]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    Returns Promise<RespShape<Resp2<[value: number, increment: number] | [value: string, increment: string]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

increxBuffer

  • increxBuffer(...args): Promise<RespShape<Resp2<[value: number, increment: number] | [value: Buffer, increment: Buffer]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<RespShape<Resp2<[value: number, increment: number] | [value: Buffer, increment: Buffer]>, Resp3<[value: number, increment: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[value: number, increment: number] | [value: Buffer, increment: Buffer]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • increxBuffer(...args): Promise<RespShape<Resp2<[value: number, increment: number] | [value: Buffer, increment: Buffer]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    Returns Promise<RespShape<Resp2<[value: number, increment: number] | [value: Buffer, increment: Buffer]>, Resp3<[value: number, increment: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

info

  • info(callback?): Promise<string>

  • Returns information and statistics about the server.

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

    Parameters

    Returns Promise<string>

  • info(...args): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • info(...args): Promise<string>

  • Parameters

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

    Returns Promise<string>

keys

  • keys(pattern, callback?): Promise<string[]>

  • Returns all key names that match a 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, callback?): Promise<Buffer[]>

  • Parameters

    • pattern: string
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

lastsave

  • lastsave(callback?): Promise<number>

  • Returns the Unix timestamp of the last successful save to disk.

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

    Parameters

    Returns Promise<number>

latency

  • latency(subcommand, callback?): Promise<string>

  • Returns 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>

  • latency(subcommand, event, callback?): Promise<string>

  • Returns a latency graph for an event.

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

    Parameters

    • subcommand: "GRAPH"
    • event: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

  • latency(subcommand, callback?): Promise<unknown[]>

  • Returns 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[]>

  • latency(subcommand, callback?): Promise<unknown>

  • Returns the cumulative distribution of latencies of a subset or all commands.

    • 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>

  • latency(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • latency(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

    Returns Promise<unknown>

  • latency(subcommand, event, callback?): Promise<unknown[]>

  • Returns timestamp-latency samples for an event.

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

    Parameters

    • subcommand: "HISTORY"
    • event: string | Buffer
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • latency(subcommand, callback?): Promise<unknown[]>

  • Returns 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[]>

  • latency(subcommand, callback?): Promise<number>

  • Resets the 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>

  • latency(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • latency(...args): Promise<number>

  • Parameters

    • Rest ...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

    Returns Promise<number>

lcs

  • lcs(key1, key2, len, idx, minMatchLenToken, minMatchLen, withmatchlen, callback?): Promise<unknown>

  • Finds the longest common substring.

    • group: string
    • complexity: O(N*M) where N and M are the lengths of s1 and s2, respectively
    • since: 7.0.0

    Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • idx: "IDX"
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, idx, minMatchLenToken, minMatchLen, withmatchlen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • idx: "IDX"
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, len, minMatchLenToken, minMatchLen, withmatchlen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, len, idx, withmatchlen, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, len, idx, minMatchLenToken, minMatchLen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • idx: "IDX"
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, minMatchLenToken, minMatchLen, withmatchlen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, idx, withmatchlen, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, idx, minMatchLenToken, minMatchLen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • idx: "IDX"
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, len, withmatchlen, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, len, minMatchLenToken, minMatchLen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, len, idx, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, withmatchlen, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, minMatchLenToken, minMatchLen, callback?): Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • minMatchLenToken: "MINMATCHLEN"
    • minMatchLen: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • lcs(key1, key2, idx, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, len, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • lcs(key1, key2, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

lindex

  • lindex(key, index, callback?): Promise<string>

  • Returns 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

    Returns Promise<string>

lindexBuffer

  • lindexBuffer(key, index, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

linsert

  • linsert(key, before, pivot, element, callback?): Promise<number>

  • Inserts 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>

  • linsert(key, after, pivot, element, callback?): 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, callback?): Promise<number>

  • Returns the length of a list.

    • group: list
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

lmove

  • lmove(source, destination, left, left1, callback?): Promise<string>

  • Returns an element after popping it from one list and pushing it to another. Deletes the list if the last element was moved.

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

    Parameters

    Returns Promise<string>

  • lmove(source, destination, left, right, callback?): Promise<string>

  • Parameters

    Returns Promise<string>

  • lmove(source, destination, right, left, callback?): Promise<string>

  • Parameters

    Returns Promise<string>

  • lmove(source, destination, right, right1, callback?): Promise<string>

  • Parameters

    Returns Promise<string>

lmoveBuffer

  • lmoveBuffer(source, destination, left, left1, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • lmoveBuffer(source, destination, left, right, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • lmoveBuffer(source, destination, right, left, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • lmoveBuffer(source, destination, right, right1, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

lmovem

  • lmovem(source, destination, left, left1, countToken, count, obo, callback?): Promise<string[]>

  • Moves up to (or exactly) a number of elements from one list to another and returns them. Deletes the source list if it becomes empty.

    • group: list
    • complexity: O(N) where N is the number of elements moved.
    • since: 8.10.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, left1, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, left1, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, left1, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, right, countToken, count, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, right, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, right, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, right, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, left, countToken, count, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, left, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, left, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, left, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, right1, countToken, count, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, right1, countToken, count, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, right1, exactlyToken, exactly, obo, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, right, right1, exactlyToken, exactly, bulk, callback?): Promise<string[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • lmovem(source, destination, left, left1, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • lmovem(source, destination, left, right, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • lmovem(source, destination, right, left, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • lmovem(source, destination, right, right1, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

lmovemBuffer

  • lmovemBuffer(source, destination, left, left1, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, left1, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, left1, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, left1, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, right, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, right, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, right, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, right, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, left, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, left, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, left, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, left, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, right1, countToken, count, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, right1, countToken, count, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • countToken: "COUNT"
    • count: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, right1, exactlyToken, exactly, obo, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • obo: "OBO"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, right1, exactlyToken, exactly, bulk, callback?): Promise<Buffer[]>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • exactlyToken: "EXACTLY"
    • exactly: string | number
    • bulk: "BULK"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, left1, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, left, right, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, left, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

  • lmovemBuffer(source, destination, right, right1, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

lmpop

  • lmpop(...args): Promise<[key: string, members: string[]]>

  • Returns multiple elements from a list after removing them. Deletes the list if the last element was popped.

    • 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", countToken: "COUNT", count: string | number, callback: Callback<[key: string, members: string[]]>]

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

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

  • lmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

  • lmpop(...args): 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[]]>

  • lmpop(...args): 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[]]>

  • lmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

  • lmpop(...args): Promise<[key: string, members: string[]]>

  • Parameters

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

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

lmpopBuffer

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

  • lmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): 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[]]>

  • lmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

  • lmpopBuffer(...args): Promise<[key: Buffer, members: Buffer[]]>

  • Parameters

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

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

lolwut

  • lolwut(versionToken, version, callback?): Promise<string>

  • Displays computer art and the Redis version

    • group: server
    • complexity: undefined
    • since: 5.0.0

    Parameters

    • versionToken: "VERSION"
    • version: string | number
    • Optional callback: Callback<string>

    Returns Promise<string>

  • lolwut(callback?): Promise<string>

  • Parameters

    Returns Promise<string>

lpop

  • lpop(key, callback?): Promise<string>

  • Returns the first elements in a list after removing it. Deletes the list if the last element was popped.

    • group: list
    • complexity: O(N) where N is the number of elements returned
    • since: 1.0.0

    Parameters

    Returns Promise<string>

  • lpop(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

lpopBuffer

lpos

  • lpos(key, element, rankToken, rank, numMatchesToken, numMatches, lenToken, len, callback?): Promise<number[]>

  • Returns the index of matching elements in 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
    • rankToken: "RANK"
    • rank: string | number
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optional callback: Callback<number[]>

    Returns Promise<number[]>

  • lpos(key, element, numMatchesToken, numMatches, lenToken, len, callback?): 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[]>

  • lpos(key, element, rankToken, rank, lenToken, len, callback?): 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>

  • lpos(key, element, rankToken, rank, numMatchesToken, numMatches, callback?): 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[]>

  • lpos(key, element, lenToken, len, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • lenToken: "MAXLEN"
    • len: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • lpos(key, element, numMatchesToken, numMatches, callback?): Promise<number[]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • Optional callback: Callback<number[]>

    Returns Promise<number[]>

  • lpos(key, element, rankToken, rank, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • lpos(key, element, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

lpush

  • lpush(...args): Promise<number>

  • Prepends one or more elements to a list. Creates the key if it doesn't exist.

    • 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>

  • lpush(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

lpushx

  • lpushx(...args): Promise<number>

  • Prepends one or more elements to a list only when 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>

  • lpushx(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

lrange

  • lrange(key, start, stop, callback?): Promise<string[]>

  • Returns 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, start, stop, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

lrem

  • lrem(key, count, element, callback?): Promise<number>

  • Removes elements from a list. Deletes the list if the last element was removed.

    • 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, index, element, callback?): Promise<"OK">

  • Sets 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, start, stop, callback?): Promise<"OK">

  • Removes elements from both ends a list. Deletes the list if all elements were trimmed.

    • 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, callback?): Promise<string>

  • Outputs a memory problems report.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

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

    Returns Promise<string>

  • memory(subcommand, callback?): Promise<unknown[]>

  • Returns 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[]>

  • memory(subcommand, callback?): Promise<string>

  • Returns the allocator statistics.

    • 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>

  • memory(subcommand, callback?): Promise<"OK">

  • Asks 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">

  • memory(subcommand, callback?): Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns details about memory usage.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "STATS"
    • Optional callback: Callback<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<unknown[]>, Resp3<Resp3Map<unknown>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • memory(subcommand, key, countToken, count, callback?): Promise<number>

  • Estimates 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
    • countToken: "SAMPLES"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • memory(subcommand, key, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

mget

  • mget(...args): Promise<string[]>

  • Atomically returns the string values of one or more keys.

    • group: string
    • complexity: O(N) where N is the number of keys to retrieve.
    • since: 1.0.0

    Parameters

    Returns Promise<string[]>

  • mget(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • mget(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • mget(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

mgetBuffer

migrate

  • migrate(...args): Promise<"OK">

  • Atomically transfers a key from one Redis instance to another.

    • 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, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, copy, replace, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, copy, replace, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, copy, replace, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, copy, replace, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, replace, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, replace, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, copy, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, copy, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, copy, replace, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, authToken: "AUTH", auth: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, auth2Token: "AUTH2", username: string | Buffer, password: string | Buffer, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, replace: "REPLACE", keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, replace, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, replace, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, copy: "COPY", keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, copy, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, copy, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, copy, replace, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, key: RedisKey, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, replace, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, copy, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", ...keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(...args): Promise<"OK">

  • Parameters

    • Rest ...args: [host: string | Buffer, port: string | number, destinationDb: string | number, timeout: string | number, keysToken: "KEYS", keys: RedisKey[]]

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, authToken, auth, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • authToken: "AUTH"
    • auth: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, auth2Token, username, password, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • auth2Token: "AUTH2"
    • username: string | Buffer
    • password: string | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, replace, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, copy, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • copy: "COPY"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, key, destinationDb, timeout, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • key: RedisKey
    • destinationDb: string | number
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • migrate(host, port, destinationDb, timeout, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • destinationDb: string | number
    • timeout: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

module

  • module(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • module(subcommand, callback?): Promise<unknown>

  • Returns all loaded modules.

    • 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>

  • module(subcommand, path, callback?): Promise<unknown>

  • Loads a module.

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "LOAD"
    • path: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Loads a module using extended parameters.

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

    Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • module(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

    Returns Promise<unknown>

  • module(subcommand, path, callback?): Promise<unknown>

  • Parameters

    • subcommand: "LOADEX"
    • path: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • module(subcommand, name, callback?): Promise<unknown>

  • Unloads 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?): Promise<Redis<"legacy">>

  • 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 the current connection.

    Parameters

    • Optional callback: Callback<Redis<"legacy">>

      The callback function. If omit, a promise will be returned.

    Returns Promise<Redis<"legacy">>

    Example

    var redis = new Redis();
    redis.monitor(function (err, monitor) {
      // Entering monitoring mode.
      monitor.on('monitor', function (time, args, source, database) {
        console.log(time + ": " + util.inspect(args));
      });
    });

    // supports promise as well as other commands
    redis.monitor().then(function (monitor) {
      monitor.on('monitor', function (time, args, source, database) {
        console.log(time + ": " + util.inspect(args));
      });
    });

move

  • move(key, db, callback?): Promise<number>

  • Moves a key to another database.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

mset

  • mset(object, callback?): Promise<"OK">

  • Atomically creates or modifies the string values of one or more keys.

    • 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">

  • mset(map, callback?): Promise<"OK">

  • Parameters

    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • mset(...args): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

  • mset(...args): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

msetex

  • msetex(...args): Promise<number>

  • Atomically sets multiple string keys with a shared expiration in a single operation. Supports flexible argument parsing where condition and expiration flags can appear in any order.

    • group: string
    • complexity: O(N) where N is the number of keys to set.
    • since: 8.4.0

    Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", secondsToken: "EX", seconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", secondsToken: "EX", seconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", millisecondsToken: "PX", milliseconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", millisecondsToken: "PX", milliseconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", keepttl: "KEEPTTL", callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", keepttl: "KEEPTTL"]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", secondsToken: "EX", seconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", secondsToken: "EX", seconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", millisecondsToken: "PX", milliseconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", millisecondsToken: "PX", milliseconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", keepttl: "KEEPTTL", callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", keepttl: "KEEPTTL"]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], secondsToken: "EX", seconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], secondsToken: "EX", seconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], millisecondsToken: "PX", milliseconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], millisecondsToken: "PX", milliseconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], unixTimeSecondsToken: "EXAT", unixTimeSeconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number, callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], unixTimeMillisecondsToken: "PXAT", unixTimeMilliseconds: string | number]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], keepttl: "KEEPTTL", callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], keepttl: "KEEPTTL"]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX", callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], nx: "NX"]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX", callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], xx: "XX"]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[], callback: Callback<number>]

    Returns Promise<number>

  • msetex(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...data: (number | RedisKey)[]]

    Returns Promise<number>

msetnx

  • msetnx(object, callback?): Promise<"OK">

  • Atomically modifies the string values of one or more keys only when all keys don't 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">

  • msetnx(map, callback?): Promise<"OK">

  • Parameters

    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • msetnx(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • msetnx(...args): Promise<number>

  • Parameters

    Returns Promise<number>

multi

object

  • object(subcommand, key, callback?): Promise<unknown>

  • Returns the internal encoding of a Redis object.

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    Returns Promise<unknown>

  • object(subcommand, key, callback?): Promise<unknown>

  • Returns the logarithmic access frequency counter of a Redis object.

    • group: generic
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    Returns Promise<unknown>

  • object(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • object(subcommand, key, callback?): Promise<unknown>

  • Returns the time since the last access to a Redis object.

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    Returns Promise<unknown>

  • object(subcommand, key, callback?): Promise<unknown>

  • Returns the reference count of a value of a key.

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    Returns Promise<unknown>

on

  • on(event, cb): this

  • Parameters

    • event: "message"
    • cb: ((channel, message) => void)
        • (channel, message): void

        • Parameters

          • channel: string
          • message: string

          Returns void

    Returns this

  • on(event, cb): this

  • Parameters

    • event: "messageBuffer"
    • cb: ((channel, message) => void)
        • (channel, message): void

        • Parameters

          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

  • on(event, cb): this

  • Parameters

    • event: "pmessage"
    • cb: ((pattern, channel, message) => void)
        • (pattern, channel, message): void

        • Parameters

          • pattern: string
          • channel: string
          • message: string

          Returns void

    Returns this

  • on(event, cb): this

  • Parameters

    • event: "pmessageBuffer"
    • cb: ((pattern, channel, message) => void)
        • (pattern, channel, message): void

        • Parameters

          • pattern: string
          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

  • on(event, cb): this

  • Parameters

    • event: "error"
    • cb: ((error) => void)
        • (error): void

        • Parameters

          • error: Error

          Returns void

    Returns this

  • on(event, cb): this

  • Parameters

    Returns this

  • on(event, listener): this

  • Parameters

    • event: string | symbol
    • listener: ((...args) => void)
        • (...args): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

once

  • once(event, cb): this

  • Parameters

    • event: "message"
    • cb: ((channel, message) => void)
        • (channel, message): void

        • Parameters

          • channel: string
          • message: string

          Returns void

    Returns this

  • once(event, cb): this

  • Parameters

    • event: "messageBuffer"
    • cb: ((channel, message) => void)
        • (channel, message): void

        • Parameters

          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

  • once(event, cb): this

  • Parameters

    • event: "pmessage"
    • cb: ((pattern, channel, message) => void)
        • (pattern, channel, message): void

        • Parameters

          • pattern: string
          • channel: string
          • message: string

          Returns void

    Returns this

  • once(event, cb): this

  • Parameters

    • event: "pmessageBuffer"
    • cb: ((pattern, channel, message) => void)
        • (pattern, channel, message): void

        • Parameters

          • pattern: string
          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

  • once(event, cb): this

  • Parameters

    • event: "error"
    • cb: ((error) => void)
        • (error): void

        • Parameters

          • error: Error

          Returns void

    Returns this

  • once(event, cb): this

  • Parameters

    Returns this

  • once(event, listener): this

  • Parameters

    • event: string | symbol
    • listener: ((...args) => void)
        • (...args): void

        • Parameters

          • Rest ...args: any[]

          Returns void

    Returns this

persist

  • persist(key, callback?): Promise<number>

  • Removes the expiration time of a key.

    • group: generic
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    Returns Promise<number>

pexpire

  • pexpire(key, milliseconds, nx, callback?): Promise<number>

  • Sets the expiration time of a key in milliseconds.

    • group: generic
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • milliseconds: string | number
    • nx: "NX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpire(key, milliseconds, xx, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • xx: "XX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpire(key, milliseconds, gt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • gt: "GT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpire(key, milliseconds, lt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • lt: "LT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpire(key, milliseconds, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

pexpireat

  • pexpireat(key, unixTimeMilliseconds, nx, callback?): Promise<number>

  • Sets the expiration time of a key to a Unix milliseconds timestamp.

    • group: generic
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpireat(key, unixTimeMilliseconds, xx, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpireat(key, unixTimeMilliseconds, gt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • gt: "GT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpireat(key, unixTimeMilliseconds, lt, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • lt: "LT"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • pexpireat(key, unixTimeMilliseconds, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

pexpiretime

  • pexpiretime(key, callback?): Promise<number>

  • Returns the expiration time of a key as a Unix milliseconds timestamp.

    • group: generic
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    Returns Promise<number>

pfadd

  • pfadd(key, callback?): Promise<number>

  • Adds elements to a HyperLogLog key. Creates the key if it doesn't exist.

    • group: hyperloglog
    • complexity: O(1) to add every element.
    • since: 2.8.9

    Parameters

    Returns Promise<number>

  • pfadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • pfadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

pfcount

  • pfcount(...args): Promise<number>

  • Returns the approximated cardinality of the set(s) observed by the HyperLogLog 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

    Returns Promise<number>

  • pfcount(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • pfcount(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • pfcount(...args): Promise<number>

  • Parameters

    Returns Promise<number>

pfdebug

  • pfdebug(subcommand, key, callback?): Promise<unknown>

  • Internal commands for debugging HyperLogLog values.

    • group: hyperloglog
    • complexity: N/A
    • since: 2.8.9

    Parameters

    Returns Promise<unknown>

pfmerge

pfselftest

  • pfselftest(callback?): Promise<unknown>

  • An internal command for testing HyperLogLog values.

    • group: hyperloglog
    • complexity: N/A
    • since: 2.8.9

    Parameters

    Returns Promise<unknown>

ping

  • ping(callback?): Promise<"PONG">

  • Returns the server's liveliness response.

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<"PONG">

  • ping(message, callback?): Promise<string>

  • Parameters

    • message: string | Buffer
    • Optional callback: Callback<string>

    Returns Promise<string>

pingBuffer

  • pingBuffer(message, callback?): Promise<Buffer>

  • Parameters

    • message: string | Buffer
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

pipeline

psetex

  • psetex(key, milliseconds, value, callback?): Promise<unknown>

  • Sets both string value and expiration time in milliseconds of a key. The key is created if it doesn't exist.

    • 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): Promise<unknown>

  • Listens for messages published to channels that match one or more patterns.

    • group: pubsub
    • complexity: O(N) where N is the number of patterns to subscribe to.
    • since: 2.0.0

    Parameters

    • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • psubscribe(...args): Promise<unknown>

  • Parameters

    • Rest ...args: string[]

    Returns Promise<unknown>

psync

  • psync(replicationid, offset, callback?): Promise<unknown>

  • An internal command used in 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, callback?): Promise<number>

  • Returns the expiration time in milliseconds of a key.

    • group: generic
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    Returns Promise<number>

publish

  • publish(channel, message, callback?): Promise<number>

  • Posts 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, callback?): Promise<unknown[]>

  • Returns the 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[]>

  • pubsub(subcommand, pattern, callback?): Promise<unknown[]>

  • Parameters

    • subcommand: "CHANNELS"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • pubsub(subcommand, callback?): Promise<unknown[]>

  • Returns 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[]>

  • pubsub(subcommand, callback?): Promise<unknown[]>

  • Returns a count of unique pattern subscriptions.

    • group: pubsub
    • complexity: O(1)
    • since: 2.8.0

    Parameters

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

    Returns Promise<unknown[]>

  • pubsub(subcommand, callback?): Promise<unknown[]>

  • Returns a count of subscribers to 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[]>

  • pubsub(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • pubsub(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • pubsub(subcommand, callback?): Promise<unknown[]>

  • Returns the 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[]>

  • pubsub(subcommand, pattern, callback?): Promise<unknown[]>

  • Parameters

    • subcommand: "SHARDCHANNELS"
    • pattern: string
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • pubsub(subcommand, callback?): Promise<unknown[]>

  • Returns the count of subscribers of 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[]>

  • pubsub(...args): Promise<unknown[]>

  • Parameters

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

    Returns Promise<unknown[]>

  • pubsub(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

    Returns Promise<unknown[]>

punsubscribe

  • punsubscribe(callback?): Promise<unknown>

  • Stops listening to messages published to channels that match one or more patterns.

    • group: pubsub
    • complexity: O(N) where N is the number of patterns to unsubscribe.
    • since: 2.0.0

    Parameters

    Returns Promise<unknown>

  • punsubscribe(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [...patterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • punsubscribe(...args): Promise<unknown>

  • Parameters

    • Rest ...args: string[]

    Returns Promise<unknown>

quit

  • quit(callback?): Promise<"OK">

  • Closes the connection.

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<"OK">

randomkey

  • randomkey(callback?): Promise<string>

  • Returns a random key name from the database.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<string>

randomkeyBuffer

  • randomkeyBuffer(callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

readonly

  • readonly(callback?): Promise<"OK">

  • Enables read-only queries for a connection to a Redis Cluster replica node.

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

    Parameters

    Returns Promise<"OK">

readwrite

  • readwrite(callback?): Promise<"OK">

  • Enables read-write queries for a connection to a Reids Cluster replica node.

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

    Parameters

    Returns Promise<"OK">

rename

  • rename(key, newkey, callback?): Promise<"OK">

  • Renames a key and overwrites the destination.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<"OK">

renamenx

  • renamenx(key, newkey, callback?): Promise<number>

  • Renames a key only when the target key name doesn't exist.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

replconf

  • replconf(callback?): Promise<unknown>

  • An internal command for configuring the replication stream.

    • group: server
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    Returns Promise<unknown>

replicaof

  • replicaof(no, one, callback?): Promise<"OK">

  • Configures a server as replica of another, or promotes it to a master.

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

    Parameters

    • no: "NO"
    • one: "ONE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • replicaof(host, port, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

reset

  • reset(callback?): Promise<"OK">

  • Resets the connection.

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

    Parameters

    Returns Promise<"OK">

restore

  • restore(key, ttl, serializedValue, replace, absttl, secondsToken, seconds, frequencyToken, frequency, callback?): Promise<"OK">

  • Creates a key from the serialized representation of a value.

    • 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
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • restore(key, ttl, serializedValue, absttl, secondsToken, seconds, frequencyToken, frequency, callback?): 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">

  • restore(key, ttl, serializedValue, replace, secondsToken, seconds, frequencyToken, frequency, callback?): 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">

  • restore(key, ttl, serializedValue, replace, absttl, frequencyToken, frequency, callback?): 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">

  • restore(key, ttl, serializedValue, replace, absttl, secondsToken, seconds, callback?): 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">

  • restore(key, ttl, serializedValue, secondsToken, seconds, frequencyToken, frequency, callback?): 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">

  • restore(key, ttl, serializedValue, absttl, frequencyToken, frequency, callback?): 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">

  • restore(key, ttl, serializedValue, absttl, secondsToken, seconds, callback?): 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">

  • restore(key, ttl, serializedValue, replace, frequencyToken, frequency, callback?): 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">

  • restore(key, ttl, serializedValue, replace, secondsToken, seconds, callback?): 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">

  • restore(key, ttl, serializedValue, replace, absttl, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • restore(key, ttl, serializedValue, frequencyToken, frequency, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • restore(key, ttl, serializedValue, secondsToken, seconds, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • restore(key, ttl, serializedValue, absttl, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • restore(key, ttl, serializedValue, replace, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • restore(key, ttl, serializedValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

restore-asking

  • restore-asking(key, ttl, serializedValue, replace, absttl, secondsToken, seconds, frequencyToken, frequency, callback?): 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
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • restore-asking(key, ttl, serializedValue, absttl, secondsToken, seconds, frequencyToken, frequency, callback?): 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>

  • restore-asking(key, ttl, serializedValue, replace, secondsToken, seconds, frequencyToken, frequency, callback?): 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>

  • restore-asking(key, ttl, serializedValue, replace, absttl, frequencyToken, frequency, callback?): 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>

  • restore-asking(key, ttl, serializedValue, replace, absttl, secondsToken, seconds, callback?): 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>

  • restore-asking(key, ttl, serializedValue, secondsToken, seconds, frequencyToken, frequency, callback?): 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>

  • restore-asking(key, ttl, serializedValue, absttl, frequencyToken, frequency, callback?): 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>

  • restore-asking(key, ttl, serializedValue, absttl, secondsToken, seconds, callback?): 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>

  • restore-asking(key, ttl, serializedValue, replace, frequencyToken, frequency, callback?): 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>

  • restore-asking(key, ttl, serializedValue, replace, secondsToken, seconds, callback?): 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>

  • restore-asking(key, ttl, serializedValue, replace, absttl, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • restore-asking(key, ttl, serializedValue, frequencyToken, frequency, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • restore-asking(key, ttl, serializedValue, secondsToken, seconds, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • restore-asking(key, ttl, serializedValue, absttl, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • restore-asking(key, ttl, serializedValue, replace, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • restore-asking(key, ttl, serializedValue, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

role

  • role(callback?): Promise<unknown[]>

  • Returns the replication role.

    • group: server
    • complexity: O(1)
    • since: 2.8.12

    Parameters

    Returns Promise<unknown[]>

rpop

  • rpop(key, callback?): Promise<string>

  • Returns and removes the last elements of a list. Deletes the list if the last element was popped.

    • group: list
    • complexity: O(N) where N is the number of elements returned
    • since: 1.0.0

    Parameters

    Returns Promise<string>

  • rpop(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

rpopBuffer

rpoplpush

  • rpoplpush(source, destination, callback?): Promise<string>

  • Returns the last element of a list after removing and pushing it to another list. Deletes the list if the last element was popped.

    • group: list
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    Returns Promise<string>

rpoplpushBuffer

rpush

  • rpush(...args): Promise<number>

  • Appends one or more elements to a list. Creates the key if it doesn't exist.

    • 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>

  • rpush(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

rpushx

  • rpushx(...args): Promise<number>

  • Appends an element to a list only when 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>

  • rpushx(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

sadd

  • sadd(...args): Promise<number>

  • Adds one or more members to a set. Creates the key if it doesn't exist.

    • 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>

  • sadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • sadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number>

  • sadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number>

save

  • save(callback?): Promise<"OK">

  • Synchronously saves the database(s) to disk.

    • group: server
    • complexity: O(N) where N is the total number of keys in all databases
    • since: 1.0.0

    Parameters

    Returns Promise<"OK">

scan

  • scan(cursor, patternToken, pattern, countToken, count, typeToken, type, callback?): Promise<[cursor: string, elements: string[]]>

  • Iterates over the key names in the database.

    • 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
    • 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[]]>

  • scan(cursor, countToken, count, typeToken, type, callback?): 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[]]>

  • scan(cursor, patternToken, pattern, typeToken, type, callback?): 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[]]>

  • scan(cursor, patternToken, pattern, countToken, count, callback?): 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[]]>

  • scan(cursor, typeToken, type, callback?): 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[]]>

  • scan(cursor, countToken, count, callback?): 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[]]>

  • scan(cursor, patternToken, pattern, callback?): 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[]]>

  • scan(cursor, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

scanBuffer

  • scanBuffer(cursor, patternToken, pattern, countToken, count, typeToken, type, callback?): 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[]]>

  • scanBuffer(cursor, countToken, count, typeToken, type, callback?): 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[]]>

  • scanBuffer(cursor, patternToken, pattern, typeToken, type, callback?): 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[]]>

  • scanBuffer(cursor, patternToken, pattern, countToken, count, callback?): 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[]]>

  • scanBuffer(cursor, typeToken, type, callback?): 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[]]>

  • scanBuffer(cursor, countToken, count, callback?): 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[]]>

  • scanBuffer(cursor, patternToken, pattern, callback?): 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[]]>

  • scanBuffer(cursor, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

scanBufferStream

scanStream

scard

  • scard(key, callback?): Promise<number>

  • Returns the number of members in a set.

    • group: set
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

script

  • script(subcommand, yes, callback?): Promise<unknown>

  • Sets the debug mode of server-side Lua scripts.

    • group: scripting
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    • subcommand: "DEBUG"
    • yes: "YES"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • script(subcommand, sync, callback?): Promise<unknown>

  • Parameters

    • subcommand: "DEBUG"
    • sync: "SYNC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • script(subcommand, no, callback?): Promise<unknown>

  • Parameters

    • subcommand: "DEBUG"
    • no: "NO"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • script(...args): Promise<unknown>

  • Determines whether server-side Lua scripts exist 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>

  • script(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

    Returns Promise<unknown>

  • script(subcommand, async, callback?): Promise<unknown>

  • Removes all server-side Lua 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"
    • async: "ASYNC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • script(subcommand, sync, callback?): Promise<unknown>

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • script(subcommand, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • script(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • script(subcommand, callback?): Promise<unknown>

  • Terminates a server-side Lua script during execution.

    • group: scripting
    • complexity: O(1)
    • since: 2.6.0

    Parameters

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

    Returns Promise<unknown>

  • script(subcommand, script, callback?): Promise<unknown>

  • Loads a server-side Lua script to 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): Promise<string[]>

  • Returns the difference of multiple sets.

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    Returns Promise<string[]>

  • sdiff(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • sdiff(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • sdiff(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

sdiffBuffer

sdiffcard

  • sdiffcard(...args): Promise<number>

  • Returns the number of members of the difference between the first set and all successive sets.

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 8.10.0

    Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sdiffcard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

sdiffstore

  • sdiffstore(...args): Promise<number>

  • Stores the difference of multiple sets in a key.

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    Returns Promise<number>

  • sdiffstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • sdiffstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • sdiffstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

select

  • select(index, callback?): Promise<"OK">

  • Changes the selected database.

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • index: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

set

  • set(key, value, secondsToken, seconds, nx, get, callback?): Promise<string>

  • Sets the string value of a key, ignoring its type. The key is created if it doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, xx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, ifeqValueToken, ifeqValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, ifneValueToken, ifneValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, nx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, xx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, ifeqValueToken, ifeqValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, ifneValueToken, ifneValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, nx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, xx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifeqValueToken, ifeqValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifneValueToken, ifneValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, nx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, xx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifeqValueToken, ifeqValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifneValueToken, ifneValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, nx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, xx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, ifeqValueToken, ifeqValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, ifneValueToken, ifneValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, ifdneDigestToken, ifdneDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, nx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, xx, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, ifeqValueToken, ifeqValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, ifneValueToken, ifneValue, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, ifdneDigestToken, ifdneDigest, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, secondsToken, seconds, nx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • nx: "NX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, secondsToken, seconds, xx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • xx: "XX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, secondsToken, seconds, ifeqValueToken, ifeqValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, secondsToken, seconds, ifneValueToken, ifneValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, secondsToken, seconds, ifdeqDigestToken, ifdeqDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, secondsToken, seconds, ifdneDigestToken, ifdneDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, millisecondsToken, milliseconds, nx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • nx: "NX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, xx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • xx: "XX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, ifeqValueToken, ifeqValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, ifneValueToken, ifneValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, ifdeqDigestToken, ifdeqDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, ifdneDigestToken, ifdneDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, nx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • nx: "NX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, xx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • xx: "XX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifeqValueToken, ifeqValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifneValueToken, ifneValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifdeqDigestToken, ifdeqDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, ifdneDigestToken, ifdneDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, nx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, xx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifeqValueToken, ifeqValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifneValueToken, ifneValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifdeqDigestToken, ifdeqDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifdneDigestToken, ifdneDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, get, callback?): Promise<string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • get: "GET"
    • Optional callback: Callback<string>

    Returns Promise<string>

  • set(key, value, keepttl, nx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • nx: "NX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, xx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • xx: "XX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, ifeqValueToken, ifeqValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, ifneValueToken, ifneValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, ifdeqDigestToken, ifdeqDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, ifdneDigestToken, ifdneDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, get, callback?): Promise<string>

  • Parameters

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

    Returns Promise<string>

  • set(key, value, nx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • nx: "NX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, xx, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • xx: "XX"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, ifeqValueToken, ifeqValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, ifneValueToken, ifneValue, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, ifdeqDigestToken, ifdeqDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, ifdneDigestToken, ifdneDigest, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, secondsToken, seconds, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, millisecondsToken, milliseconds, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeSecondsToken, unixTimeSeconds, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, keepttl, callback?): Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • set(key, value, callback?): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

setBuffer

  • setBuffer(key, value, secondsToken, seconds, nx, get, callback?): 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>

  • setBuffer(key, value, secondsToken, seconds, xx, get, callback?): 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>

  • setBuffer(key, value, secondsToken, seconds, ifeqValueToken, ifeqValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, secondsToken, seconds, ifneValueToken, ifneValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, secondsToken, seconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, secondsToken, seconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, millisecondsToken, milliseconds, nx, get, callback?): 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>

  • setBuffer(key, value, millisecondsToken, milliseconds, xx, get, callback?): 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>

  • setBuffer(key, value, millisecondsToken, milliseconds, ifeqValueToken, ifeqValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, millisecondsToken, milliseconds, ifneValueToken, ifneValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, millisecondsToken, milliseconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, millisecondsToken, milliseconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, nx, get, callback?): 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>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, xx, get, callback?): 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>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, ifeqValueToken, ifeqValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, ifneValueToken, ifneValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, nx, get, callback?): 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>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, xx, get, callback?): 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>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifeqValueToken, ifeqValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifneValueToken, ifneValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, ifdneDigestToken, ifdneDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, nx, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, xx, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, ifeqValueToken, ifeqValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, ifneValueToken, ifneValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, ifdneDigestToken, ifdneDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, nx, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • nx: "NX"
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, xx, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • xx: "XX"
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, ifeqValueToken, ifeqValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifeqValueToken: "IFEQ"
    • ifeqValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, ifneValueToken, ifneValue, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifneValueToken: "IFNE"
    • ifneValue: string | number | Buffer
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, ifdeqDigestToken, ifdeqDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifdeqDigestToken: "IFDEQ"
    • ifdeqDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, ifdneDigestToken, ifdneDigest, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • ifdneDigestToken: "IFDNE"
    • ifdneDigest: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, secondsToken, seconds, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, millisecondsToken, milliseconds, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeSecondsToken, unixTimeSeconds, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, unixTimeMillisecondsToken, unixTimeMilliseconds, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, keepttl, get, callback?): Promise<Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • get: "GET"
    • Optional callback: Callback<Buffer>

    Returns Promise<Buffer>

  • setBuffer(key, value, get, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

setbit

  • setbit(key, offset, value, callback?): Promise<number>

  • Sets or clears the bit at offset of the string value. Creates the key if it doesn't exist.

    • 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, seconds, value, callback?): Promise<"OK">

  • Sets the string value and expiration time of a key. Creates the key if it doesn't exist.

    • 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, value, callback?): Promise<number>

  • Set the string value of a key only when the key doesn't exist.

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

setrange

  • setrange(key, offset, value, callback?): Promise<number>

  • Overwrites a part of a string value with another by an offset. Creates the key if it doesn't exist.

    • 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(nosave, now, force, abort, callback?): Promise<"OK">

  • Synchronously saves the database(s) to disk and shuts down the Redis 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

    • nosave: "NOSAVE"
    • now: "NOW"
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, now, force, abort, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(now, force, abort, callback?): Promise<"OK">

  • Parameters

    • now: "NOW"
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, force, abort, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, now, abort, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, now, force, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, force, abort, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, now, abort, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, now, force, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(force, abort, callback?): Promise<"OK">

  • Parameters

    • force: "FORCE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(now, abort, callback?): Promise<"OK">

  • Parameters

    • now: "NOW"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(now, force, callback?): Promise<"OK">

  • Parameters

    • now: "NOW"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, abort, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, force, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, now, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, abort, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, force, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • force: "FORCE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, now, callback?): Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(abort, callback?): Promise<"OK">

  • Parameters

    • abort: "ABORT"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(force, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • shutdown(now, callback?): Promise<"OK">

  • Parameters

    • now: "NOW"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(nosave, callback?): Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • shutdown(save, callback?): Promise<"OK">

  • Parameters

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

    Returns Promise<"OK">

  • shutdown(callback?): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

sinter

  • sinter(...args): Promise<string[]>

  • Returns the intersect of 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

    Returns Promise<string[]>

  • sinter(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • sinter(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • sinter(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

sinterBuffer

sintercard

  • sintercard(...args): Promise<number>

  • Returns the number of members of the intersect of 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: 7.0.0

    Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

sinterstore

  • sinterstore(...args): Promise<number>

  • Stores the intersect of multiple sets 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

    Returns Promise<number>

  • sinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • sinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • sinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

sismember

  • sismember(key, member, callback?): Promise<number>

  • Determines whether a member belongs to 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(no, one, callback?): Promise<"OK">

  • Sets a Redis server as a replica of another, or promotes it to being a master.

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

    Parameters

    • no: "NO"
    • one: "ONE"
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

  • slaveof(host, port, callback?): Promise<"OK">

  • Parameters

    • host: string | Buffer
    • port: string | number
    • Optional callback: Callback<"OK">

    Returns Promise<"OK">

slowlog

  • slowlog(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • slowlog(subcommand, count, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • slowlog(subcommand, callback?): 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>

  • slowlog(subcommand, callback?): Promise<unknown>

  • Returns the number of entries in the slow log.

    • group: server
    • complexity: O(1)
    • since: 2.2.12

    Parameters

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

    Returns Promise<unknown>

  • slowlog(subcommand, callback?): Promise<unknown>

  • Clears 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, callback?): Promise<string[]>

  • Returns all members of a set.

    • group: set
    • complexity: O(N) where N is the set cardinality.
    • since: 1.0.0

    Parameters

    Returns Promise<string[]>

smembersBuffer

smismember

  • smismember(...args): Promise<number[]>

  • Determines whether multiple members belong to 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[]>

  • smismember(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • smismember(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number[]>

  • smismember(...args): Promise<number[]>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number[]>

smove

  • smove(source, destination, member, callback?): Promise<number>

  • Moves a member from one set to another.

    • group: set
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

sort

  • sort(...args): Promise<number | unknown[]>

  • Sorts the elements in a list, a set, or a sorted set, optionally storing the result.

    • 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

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, asc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, desc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, asc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, desc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, asc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • asc: "ASC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, desc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • desc: "DESC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, asc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, asc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, desc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, desc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<number | unknown[]>

  • sort(key, asc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • asc: "ASC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, desc, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • desc: "DESC"
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, asc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, asc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, desc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, desc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, asc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • asc: "ASC"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, asc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, desc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • desc: "DESC"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, desc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, asc, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, desc, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<number | unknown[]>

  • sort(key, alpha, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • alpha: "ALPHA"
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, asc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

  • sort(key, asc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, desc, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

  • sort(key, desc, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey, callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], destinationToken: "STORE", destination: RedisKey]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, asc, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, desc, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • destinationToken: "STORE"
    • destination: RedisKey
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • alpha: "ALPHA"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, asc, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • asc: "ASC"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, desc, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • desc: "DESC"
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, limitToken, offset, count, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, destinationToken, destination, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

  • sort(key, alpha, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

  • sort(key, asc, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

  • sort(key, desc, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<number | unknown[]>]

    Returns Promise<number | unknown[]>

  • sort(...args): Promise<number | unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<number | unknown[]>

  • sort(key, limitToken, offset, count, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, byPatternToken, byPattern, callback?): Promise<number | unknown[]>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • Optional callback: Callback<number | unknown[]>

    Returns Promise<number | unknown[]>

  • sort(key, callback?): Promise<number | unknown[]>

  • Parameters

    Returns Promise<number | unknown[]>

sort_ro

  • sort_ro(...args): Promise<unknown>

  • Returns the sorted elements of a list, a set, or a 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: 7.0.0

    Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, limitToken, offset, count, asc, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, limitToken, offset, count, desc, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(key, limitToken, offset, count, asc, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, limitToken, offset, count, desc, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, asc, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, desc, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, limitToken, offset, count, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, limitToken, offset, count, asc, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, limitToken, offset, count, desc, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<unknown>

  • sort_ro(key, asc, alpha, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • sort_ro(key, desc, alpha, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], asc: "ASC"]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], desc: "DESC"]

    Returns Promise<unknown>

  • sort_ro(key, limitToken, offset, count, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, limitToken, offset, count, asc, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, limitToken, offset, count, desc, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, limitToken: "LIMIT", offset: string | number, count: string | number, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, alpha, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • alpha: "ALPHA"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, asc, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • asc: "ASC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, desc, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • desc: "DESC"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, byPatternToken: "BY", byPattern: string, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, limitToken, offset, count, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, alpha, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • sort_ro(key, asc, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • sort_ro(key, desc, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • sort_ro(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, getPatternToken: "GET", ...getPatterns: string[]]

    Returns Promise<unknown>

  • sort_ro(key, limitToken, offset, count, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, byPatternToken, byPattern, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • byPatternToken: "BY"
    • byPattern: string
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • sort_ro(key, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

spop

  • spop(key, callback?): Promise<string>

  • Returns one or more random members from a set after removing them. Deletes the set if the last member was popped.

    • 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

    Returns Promise<string>

  • spop(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

spopBuffer

spublish

  • spublish(shardchannel, message, callback?): 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, callback?): 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

    Returns Promise<string>

  • srandmember(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

srandmemberBuffer

  • srandmemberBuffer(key, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • srandmemberBuffer(key, count, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

srem

  • srem(...args): Promise<number>

  • Removes one or more members from a set. Deletes the set if the last member was removed.

    • 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>

  • srem(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • srem(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number>

  • srem(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number>

sscan

  • sscan(key, cursor, patternToken, pattern, countToken, count, callback?): Promise<[cursor: string, elements: string[]]>

  • Iterates over members of a set.

    • 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
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • sscan(key, cursor, countToken, count, callback?): 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[]]>

  • sscan(key, cursor, patternToken, pattern, callback?): 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[]]>

  • sscan(key, cursor, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

sscanBuffer

  • sscanBuffer(key, cursor, patternToken, pattern, countToken, count, callback?): 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[]]>

  • sscanBuffer(key, cursor, countToken, count, callback?): 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[]]>

  • sscanBuffer(key, cursor, patternToken, pattern, callback?): 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[]]>

  • sscanBuffer(key, cursor, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

sscanBufferStream

sscanStream

ssubscribe

  • ssubscribe(...args): Promise<unknown>

  • Listens for messages published to 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>

  • ssubscribe(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

strlen

  • strlen(key, callback?): Promise<number>

  • Returns the length of a string value.

    • group: string
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    Returns Promise<number>

subscribe

  • subscribe(...args): Promise<unknown>

  • Listens for messages published to 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>

  • subscribe(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

substr

  • substr(key, start, end, callback?): Promise<unknown>

  • Returns a substring from a string value.

    • 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): Promise<string[]>

  • Returns the union of multiple sets.

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    Returns Promise<string[]>

  • sunion(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • sunion(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

  • sunion(...args): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

sunionBuffer

sunioncard

  • sunioncard(...args): Promise<number>

  • Returns the number of members of the union of multiple sets.

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 8.10.0

    Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], approx: "APPROX", limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], approx: "APPROX", limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], approx: "APPROX", limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], approx: "APPROX", limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], approx: "APPROX", callback: Callback<number>]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], approx: "APPROX", callback: Callback<number>]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], approx: "APPROX"]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], approx: "APPROX"]

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • sunioncard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

sunionstore

  • sunionstore(...args): Promise<number>

  • Stores the union of multiple sets in a key.

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    Returns Promise<number>

  • sunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • sunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • sunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

sunsubscribe

  • sunsubscribe(callback?): Promise<unknown>

  • Stops listening to messages posted to shard channels.

    • group: pubsub
    • complexity: O(N) where N is the number of shard channels to unsubscribe.
    • since: 7.0.0

    Parameters

    Returns Promise<unknown>

  • sunsubscribe(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • sunsubscribe(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

swapdb

  • swapdb(index1, index2, callback?): 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?): Promise<unknown>

  • An internal command used in replication.

    • group: server
    • complexity: undefined
    • since: 1.0.0

    Parameters

    Returns Promise<unknown>

time

  • time(callback?): Promise<number[]>

  • Returns the server time.

    • group: server
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    Returns Promise<number[]>

touch

  • touch(...args): Promise<number>

  • Returns the number of existing keys out of those specified after updating the time they were last accessed.

    • group: generic
    • complexity: O(N) where N is the number of keys that will be touched.
    • since: 3.2.1

    Parameters

    Returns Promise<number>

  • touch(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • touch(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • touch(...args): Promise<number>

  • Parameters

    Returns Promise<number>

ttl

  • ttl(key, callback?): Promise<number>

  • Returns the expiration time in seconds of a key.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<number>

type

  • type(key, callback?): Promise<string>

  • Determines the type of value stored at a key.

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    Returns Promise<string>

unlink

  • unlink(...args): Promise<number>

  • Asynchronously deletes one or more keys.

    • 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

    Returns Promise<number>

  • unlink(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • unlink(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • unlink(...args): Promise<number>

  • Parameters

    Returns Promise<number>

unsubscribe

  • unsubscribe(callback?): Promise<unknown>

  • Stops listening to messages posted to channels.

    • group: pubsub
    • complexity: O(N) where N is the number of channels to unsubscribe.
    • since: 2.0.0

    Parameters

    Returns Promise<unknown>

  • unsubscribe(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • unsubscribe(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

unwatch

  • unwatch(callback?): Promise<"OK">

  • Forgets about watched keys of a transaction.

    • group: transactions
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    Returns Promise<"OK">

vadd

  • vadd(...args): Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Add one or more elements to a vector set, or update its vector if it already exists

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    • Rest ...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<RespShape<Resp2<number>, Resp3<boolean>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • vadd(...args): Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    Returns Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vcard

  • vcard(key, callback?): Promise<number>

  • Return the number of elements in a vector set

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    Returns Promise<number>

vdim

  • vdim(key, callback?): Promise<number>

  • Return the dimension of vectors in the vector set

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    Returns Promise<number>

vemb

  • vemb(key, element, raw, callback?): Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Return the vector associated with an element

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • raw: "RAW"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • vemb(key, element, callback?): Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vembBuffer

  • vembBuffer(key, element, raw, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • raw: "RAW"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • vembBuffer(key, element, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vgetattr

  • vgetattr(key, element, callback?): Promise<string>

  • Retrieve the JSON attributes of elements

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

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

    Returns Promise<string>

vgetattrBuffer

  • vgetattrBuffer(key, element, callback?): Promise<Buffer>

  • Parameters

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

    Returns Promise<Buffer>

vinfo

  • vinfo(key, callback?): Promise<RespShape<Resp2<(string | number)[]>, Resp3<Resp3Map<string | number>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Return information about a vector set

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    • key: RedisKey
    • Optional callback: Callback<RespShape<Resp2<(string | number)[]>, Resp3<Resp3Map<string | number>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<(string | number)[]>, Resp3<Resp3Map<string | number>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vinfoBuffer

  • vinfoBuffer(key, callback?): Promise<RespShape<Resp2<(number | Buffer)[]>, Resp3<Resp3Map<number | Buffer>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • Optional callback: Callback<RespShape<Resp2<(number | Buffer)[]>, Resp3<Resp3Map<number | Buffer>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<(number | Buffer)[]>, Resp3<Resp3Map<number | Buffer>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vismember

  • vismember(key, element, callback?): Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Check if an element exists in a vector set

    • group: module
    • complexity: undefined
    • since: 8.2.0

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<RespShape<Resp2<number>, Resp3<boolean>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vlinks

  • vlinks(key, element, withscores, callback?): Promise<string[][]>

  • Return the neighbors of an element at each layer in the HNSW graph

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • withscores: "WITHSCORES"
    • Optional callback: Callback<string[][]>

    Returns Promise<string[][]>

  • vlinks(key, element, callback?): Promise<string[][]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<string[][]>

    Returns Promise<string[][]>

vlinksBuffer

  • vlinksBuffer(key, element, withscores, callback?): Promise<Buffer[][]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • withscores: "WITHSCORES"
    • Optional callback: Callback<Buffer[][]>

    Returns Promise<Buffer[][]>

  • vlinksBuffer(key, element, callback?): Promise<Buffer[][]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<Buffer[][]>

    Returns Promise<Buffer[][]>

vrandmember

  • vrandmember(key, callback?): Promise<string>

  • Return one or multiple random members from a vector set

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    Returns Promise<string>

  • vrandmember(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

vrandmemberBuffer

  • vrandmemberBuffer(key, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • vrandmemberBuffer(key, count, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

vrange

  • vrange(key, start, end, callback?): Promise<string[]>

  • Return vector set elements in a lex range

    • group: module
    • complexity: undefined
    • since: 8.4.0

    Parameters

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

    Returns Promise<string[]>

  • vrange(key, start, end, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

vrangeBuffer

  • vrangeBuffer(key, start, end, callback?): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • vrangeBuffer(key, start, end, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

vrem

  • vrem(key, element, callback?): Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Remove an element from a vector set

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optional callback: Callback<RespShape<Resp2<number>, Resp3<boolean>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vsetattr

  • vsetattr(key, element, json, callback?): Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Associate or remove the JSON attributes of elements

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • json: string | Buffer
    • Optional callback: Callback<RespShape<Resp2<number>, Resp3<boolean>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<number>, Resp3<boolean>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vsim

  • vsim<T>(...args): Promise<VsimReply<T, string, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Return elements by vector similarity

    • group: module
    • complexity: undefined
    • since: 8.0.0

    Type Parameters

    Parameters

    • Rest ...args: [key: RedisKey, ...args: T[], callback: Callback<VsimReply<T, string, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<VsimReply<T, string, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • vsim<T>(...args): Promise<VsimReply<T, string, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Type Parameters

    Parameters

    Returns Promise<VsimReply<T, string, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

vsimBuffer

  • vsimBuffer<T>(...args): Promise<VsimReply<T, Buffer, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Type Parameters

    Parameters

    • Rest ...args: [key: RedisKey, ...args: T[], callback: Callback<VsimReply<T, Buffer, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<VsimReply<T, Buffer, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • vsimBuffer<T>(...args): Promise<VsimReply<T, Buffer, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Type Parameters

    Parameters

    Returns Promise<VsimReply<T, Buffer, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

wait

  • wait(numreplicas, timeout, callback?): Promise<number>

  • Blocks until the asynchronous replication of all preceding write commands sent by the connection is completed.

    • 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): Promise<"OK">

  • Monitors changes to keys to determine the execution of a transaction.

    • group: transactions
    • complexity: O(1) for every key.
    • since: 2.2.0

    Parameters

    Returns Promise<"OK">

  • watch(...args): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

  • watch(...args): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

  • watch(...args): Promise<"OK">

  • Parameters

    Returns Promise<"OK">

xack

  • xack(...args): Promise<number>

  • Returns the number of messages that were successfully acknowledged by the consumer group member of a stream.

    • 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>

  • xack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

xadd

  • xadd(...args): Promise<string>

  • Appends a new message to a stream. Creates the key if it doesn't exist.

    • 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>

  • xadd(...args): Promise<string>

  • Parameters

    Returns Promise<string>

xaddBuffer

xautoclaim

  • xautoclaim(key, group, consumer, minIdleTime, start, countToken, count, justid, callback?): Promise<unknown[]>

  • Changes, or acquires, ownership of messages in a consumer group, as if the messages were delivered to as consumer group member.

    • 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
    • countToken: "COUNT"
    • count: string | number
    • justid: "JUSTID"
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • xautoclaim(key, group, consumer, minIdleTime, start, justid, callback?): 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[]>

  • xautoclaim(key, group, consumer, minIdleTime, start, countToken, count, callback?): 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[]>

  • xautoclaim(key, group, consumer, minIdleTime, start, callback?): 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[]>

xclaim

  • xclaim(...args): Promise<unknown[]>

  • Changes, or acquires, ownership of a message in a consumer group, as if the message was delivered a consumer group member.

    • 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)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): 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, lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], lastidToken: "LASTID", lastid: string | number | Buffer, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], lastidToken: "LASTID", lastid: string | number | Buffer]

    Returns Promise<unknown[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): 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[]>

  • xclaim(...args): Promise<unknown[]>

  • 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[]>

  • xclaim(...args): Promise<unknown[]>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]

    Returns Promise<unknown[]>

xdel

  • xdel(...args): Promise<number>

  • Returns the number of messages after removing them from a stream.

    • 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>

  • xdel(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

xdelex

  • xdelex(...args): Promise<unknown>

  • Deletes one or multiple entries from the stream.

    • group: stream
    • complexity: O(1) for each single item to delete in the stream, regardless of the stream size.
    • since: 8.2.0

    Parameters

    • Rest ...args: [key: RedisKey, keepref: "KEEPREF", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, keepref: "KEEPREF", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, delref: "DELREF", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, delref: "DELREF", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, acked: "ACKED", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, acked: "ACKED", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • xdelex(...args): Promise<unknown>

  • Parameters

    • Rest ...args: [key: RedisKey, idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<unknown>

xgroup

  • xgroup(subcommand, key, group, newId, mkstream, entriesreadToken, entriesread, callback?): Promise<unknown>

  • Creates a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • mkstream: "MKSTREAM"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, id, mkstream, entriesreadToken, entriesread, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • mkstream: "MKSTREAM"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, newId, entriesreadToken, entriesread, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, newId, mkstream, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • mkstream: "MKSTREAM"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, id, entriesreadToken, entriesread, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, id, mkstream, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • mkstream: "MKSTREAM"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, newId, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, id, callback?): Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, consumer, callback?): Promise<unknown>

  • Creates a consumer in a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "CREATECONSUMER"
    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, consumer, callback?): Promise<unknown>

  • Deletes a consumer from a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "DELCONSUMER"
    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, callback?): Promise<unknown>

  • Destroys 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
    • group: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • xgroup(subcommand, key, group, newId, entriesreadToken, entriesread, callback?): Promise<unknown>

  • Sets the last-delivered ID of a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, id, entriesreadToken, entriesread, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • entriesreadToken: "ENTRIESREAD"
    • entriesread: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, newId, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • newId: "$"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xgroup(subcommand, key, group, id, callback?): Promise<unknown>

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • group: string | Buffer
    • id: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

xinfo

  • xinfo(subcommand, key, group, callback?): Promise<unknown>

  • Returns a list of the consumers in a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "CONSUMERS"
    • key: RedisKey
    • group: string | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xinfo(subcommand, key, callback?): Promise<unknown>

  • Returns a list of the consumer groups of a stream.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    Returns Promise<unknown>

  • xinfo(subcommand, callback?): Promise<unknown>

  • Returns 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>

  • xinfo(subcommand, key, full, countToken, count, callback?): Promise<unknown>

  • Returns information about a stream.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "STREAM"
    • key: RedisKey
    • full: "FULL"
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xinfo(subcommand, key, full, callback?): Promise<unknown>

  • Parameters

    • subcommand: "STREAM"
    • key: RedisKey
    • full: "FULL"
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xinfo(subcommand, key, callback?): Promise<unknown>

  • Parameters

    Returns Promise<unknown>

xlen

  • xlen(key, callback?): Promise<number>

  • Return the number of messages in a stream.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    Returns Promise<number>

xnack

  • xnack(...args): Promise<number>

  • Releases claimed messages back to the group's PEL without acknowledging them, making them available for re-delivery.

    • group: stream
    • complexity: O(1) for each message ID processed.
    • since: 8.8.0

    Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], force: "FORCE"]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], force: "FORCE"]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], force: "FORCE"]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, silent: "SILENT", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fail: "FAIL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • xnack(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, group: string | Buffer, fatal: "FATAL", idsToken: "IDS", numids: string | number, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

xpending

  • xpending(key, group, minIdleTimeToken, minIdleTime, start, end, count, callback?): Promise<unknown[]>

  • Returns the information and entries from a stream consumer group's pending entries list.

    • 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
    • minIdleTimeToken: "IDLE"
    • minIdleTime: string | number
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optional callback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • xpending(key, group, minIdleTimeToken, minIdleTime, start, end, count, consumer, callback?): 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[]>

  • xpending(key, group, callback?): Promise<unknown[]>

  • Parameters

    Returns Promise<unknown[]>

  • xpending(key, group, start, end, count, callback?): 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[]>

  • xpending(key, group, start, end, count, consumer, callback?): 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[]>

xrange

  • xrange(key, start, end, countToken, count, callback?): Promise<[id: string, fields: string[]][]>

  • Returns the messages from a stream within a range of IDs.

    • 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
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

  • xrange(key, start, end, callback?): Promise<[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[]][]>

xrangeBuffer

  • xrangeBuffer(key, start, end, countToken, count, callback?): 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[]][]>

  • xrangeBuffer(key, start, end, callback?): 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[]][]>

xread

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns messages from multiple streams with IDs greater than the ones requested. Blocks until a message is available otherwise.

    • group: stream
    • complexity: undefined
    • since: 5.0.0

    Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xread(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

xreadBuffer

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

xreadgroup

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns new or historical messages from a stream for a consumer in a group. Blocks until a message is available otherwise.

    • 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: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "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<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "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<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroup(...args): Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: string, items: [id: string, fields: string[]][]][]>, Resp3<Resp3Map<[id: string, fields: string[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

xreadgroupBuffer

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "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<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "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<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, minIdleTimeToken: "CLAIM", minIdleTime: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxsizeToken: "MAXSIZE", maxsize: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, maxcountToken: "MAXCOUNT", maxcount: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • xreadgroupBuffer(...args): Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [groupBlockToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<RespShape<Resp2<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>, Resp3<Resp3Map<[id: Buffer, fields: Buffer[]][]>>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

xrevrange

  • xrevrange(key, end, start, countToken, count, callback?): Promise<[id: string, fields: string[]][]>

  • Returns the messages from a stream within a range of IDs in reverse order.

    • 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
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

  • xrevrange(key, end, start, callback?): Promise<[id: string, fields: string[]][]>

  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • Optional callback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

xrevrangeBuffer

  • xrevrangeBuffer(key, end, start, countToken, count, callback?): 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[]][]>

  • xrevrangeBuffer(key, end, start, callback?): 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[]][]>

xsetid

  • xsetid(key, lastId, entriesAddedToken, entriesAdded, maxDeletedIdToken, maxDeletedId, callback?): 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
    • entriesAddedToken: "ENTRIESADDED"
    • entriesAdded: string | number
    • maxDeletedIdToken: "MAXDELETEDID"
    • maxDeletedId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xsetid(key, lastId, maxDeletedIdToken, maxDeletedId, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • maxDeletedIdToken: "MAXDELETEDID"
    • maxDeletedId: string | number | Buffer
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xsetid(key, lastId, entriesAddedToken, entriesAdded, callback?): Promise<unknown>

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • entriesAddedToken: "ENTRIESADDED"
    • entriesAdded: string | number
    • Optional callback: Callback<unknown>

    Returns Promise<unknown>

  • xsetid(key, lastId, callback?): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

xtrim

  • xtrim(key, maxlen, equal, threshold, countToken, count, keepref, callback?): Promise<number>

  • Deletes messages from the beginning of a stream.

    • 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"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, countToken, count, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, countToken, count, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, countToken, count, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, countToken, count, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, countToken, count, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, countToken, count, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, countToken, count, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, countToken, count, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, countToken, count, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, countToken, count, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, countToken, count, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, countToken, count, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, countToken, count, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, countToken, count, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, countToken, count, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, countToken, count, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, countToken, count, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, countToken, count, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, countToken, count, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, countToken, count, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, countToken, count, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, countToken, count, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, equal, threshold, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, approximately, threshold, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, keepref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • keepref: "KEEPREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, delref, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • delref: "DELREF"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, acked, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • acked: "ACKED"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, countToken, count, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, equal, threshold, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, approximately, threshold, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, maxlen, threshold, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

  • xtrim(key, minid, threshold, callback?): Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • Optional callback: Callback<number>

    Returns Promise<number>

zadd

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Adds one or more members to a sorted set, or updates their scores. Creates the key if it doesn't exist.

    • 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, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ...data: (string | number | Buffer)[]]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zadd(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...data: (string | number | Buffer)[]]

    Returns Promise<number>

zaddBuffer

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ch: "CH", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, gt: "GT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, lt: "LT", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, nx: "NX", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, xx: "XX", incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, incr: "INCR", ...data: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zaddBuffer(...args): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, incr: "INCR", ...data: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zcard

  • zcard(key, callback?): Promise<number>

  • Returns the number of members in a sorted set.

    • group: sorted-set
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    Returns Promise<number>

zcount

  • zcount(key, min, max, callback?): Promise<number>

  • Returns the count of members in a sorted set that have scores within a range.

    • 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): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the difference between 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[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiff(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiff(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiff(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiff(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zdiff(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zdiff(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zdiff(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

zdiffBuffer

  • zdiffBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiffBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiffBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiffBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zdiffBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zdiffBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zdiffBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zdiffBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

zdiffstore

  • zdiffstore(...args): Promise<number>

  • Stores the difference of multiple sorted sets in a 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

    Returns Promise<number>

  • zdiffstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zdiffstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zdiffstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

zincrby

  • zincrby(key, increment, member, callback?): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Increments 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<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zincrbyBuffer

  • zincrbyBuffer(key, increment, member, callback?): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • increment: string | number
    • member: string | number | Buffer
    • Optional callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zinter

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the intersect of 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[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<string[]>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • zinter(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<string[]>

zinterBuffer

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zinterBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<Buffer[]>

zintercard

  • zintercard(...args): Promise<number>

  • Returns the number of members of the intersect of multiple sorted sets.

    • 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[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zintercard(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

zinterstore

  • zinterstore(...args): Promise<number>

  • Stores the intersect of multiple sorted sets in a 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[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<number>]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zinterstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

zlexcount

  • zlexcount(key, min, max, callback?): Promise<number>

  • Returns the number of members in a sorted set within a 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): Promise<unknown>

  • Returns the highest- or lowest-scoring members from one or more sorted sets after removing them. Deletes the sorted set if the last member was popped.

    • group: sorted-set
    • complexity: O(K) + O(M*log(N)) 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", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

  • zmpop(...args): Promise<unknown>

  • Parameters

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

    Returns Promise<unknown>

zmscore

  • zmscore(...args): Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the score of one or more 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<RespShape<Resp2<string[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zmscore(...args): Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<string[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zmscore(...args): Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zmscore(...args): Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zmscoreBuffer

  • zmscoreBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zmscoreBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zmscoreBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zmscoreBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<number[]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zpopmax

  • zpopmax(key, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[] | [member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the highest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

    • 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<RespShape<Resp2<string[]>, Resp3<[] | [member: string, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[] | [member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zpopmax(key, count, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zpopmaxBuffer

  • zpopmaxBuffer(key, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[] | [member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[] | [member: Buffer, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[] | [member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zpopmaxBuffer(key, count, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zpopmin

  • zpopmin(key, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[] | [member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the lowest-scoring members from a sorted set after removing them. Deletes the sorted set if the last member was popped.

    • 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<RespShape<Resp2<string[]>, Resp3<[] | [member: string, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[] | [member: string, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zpopmin(key, count, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zpopminBuffer

  • zpopminBuffer(key, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[] | [member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[] | [member: Buffer, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[] | [member: Buffer, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zpopminBuffer(key, count, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zrandmember

  • zrandmember(key, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns one or more random members from a sorted set.

    • group: sorted-set
    • complexity: O(N) where N is the number of members returned
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrandmember(key, callback?): Promise<string>

  • Parameters

    Returns Promise<string>

  • zrandmember(key, count, callback?): Promise<string[]>

  • Parameters

    Returns Promise<string[]>

zrandmemberBuffer

  • zrandmemberBuffer(key, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrandmemberBuffer(key, callback?): Promise<Buffer>

  • Parameters

    Returns Promise<Buffer>

  • zrandmemberBuffer(key, count, callback?): Promise<Buffer[]>

  • Parameters

    Returns Promise<Buffer[]>

zrange

  • zrange(key, start, stop, byscore, rev, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns members in a sorted set within a range of 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 returned.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, bylex, rev, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, rev, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, byscore, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, byscore, rev, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, byscore, rev, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, bylex, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, bylex, rev, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, bylex, rev, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, rev, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, rev, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, byscore, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, byscore, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, byscore, rev, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, bylex, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, bylex, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, bylex, rev, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrange(key, start, stop, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, rev, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, byscore, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, bylex, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrange(key, start, stop, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

zrangeBuffer

  • zrangeBuffer(key, start, stop, byscore, rev, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, bylex, rev, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, rev, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, byscore, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, byscore, rev, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, byscore, rev, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, bylex, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, bylex, rev, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, bylex, rev, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, limitToken, offset, count, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, rev, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, rev, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, byscore, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, byscore, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, byscore, rev, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, bylex, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, bylex, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, bylex, rev, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangeBuffer(key, start, stop, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, rev, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • rev: "REV"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, byscore, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • byscore: "BYSCORE"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, bylex, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • bylex: "BYLEX"
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangeBuffer(key, start, stop, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • stop: string | Buffer
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

zrangebylex

  • zrangebylex(key, min, max, limitToken, offset, count, callback?): Promise<string[]>

  • Returns members in a sorted set within a 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
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrangebylex(key, min, max, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

zrangebylexBuffer

  • zrangebylexBuffer(key, min, max, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangebylexBuffer(key, min, max, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

zrangebyscore

  • zrangebyscore(key, min, max, withscores, limitToken, offset, count, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns members in a sorted set within a range of 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 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
    • withscores: "WITHSCORES"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangebyscore(key, min, max, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrangebyscore(key, min, max, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangebyscore(key, min, max, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

zrangebyscoreBuffer

  • zrangebyscoreBuffer(key, min, max, withscores, limitToken, offset, count, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangebyscoreBuffer(key, min, max, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrangebyscoreBuffer(key, min, max, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrangebyscoreBuffer(key, min, max, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

zrangestore

  • zrangestore(dst, src, min, max, byscore, rev, limitToken, offset, count, callback?): Promise<number>

  • Stores a range of members from sorted set in a 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
    • byscore: "BYSCORE"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, bylex, rev, limitToken, offset, count, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, rev, limitToken, offset, count, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, byscore, limitToken, offset, count, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, byscore, rev, callback?): 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>

  • zrangestore(dst, src, min, max, bylex, limitToken, offset, count, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, bylex, rev, callback?): 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>

  • zrangestore(dst, src, min, max, limitToken, offset, count, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, rev, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, byscore, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, bylex, callback?): Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • Optional callback: Callback<number>

    Returns Promise<number>

  • zrangestore(dst, src, min, max, callback?): Promise<number>

  • Parameters

    Returns Promise<number>

zrank

  • zrank(key, member, withscore, callback?): Promise<RespShape<Resp2<[rank: number, score: string]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the index of a member in a sorted set ordered by ascending scores.

    • group: sorted-set
    • complexity: O(log(N))
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • withscore: "WITHSCORE"
    • Optional callback: Callback<RespShape<Resp2<[rank: number, score: string]>, Resp3<[rank: number, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<[rank: number, score: string]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrank(key, member, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

zrankBuffer

  • zrankBuffer(key, member, withscore, callback?): Promise<RespShape<Resp2<[rank: number, score: Buffer]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • withscore: "WITHSCORE"
    • Optional callback: Callback<RespShape<Resp2<[rank: number, score: Buffer]>, Resp3<[rank: number, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<[rank: number, score: Buffer]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zrem

  • zrem(...args): Promise<number>

  • Removes one or more members from a sorted set. Deletes the sorted set if all members were removed.

    • 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>

  • zrem(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • zrem(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number>

  • zrem(...args): Promise<number>

  • Parameters

    • Rest ...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number>

zremrangebylex

  • zremrangebylex(key, min, max, callback?): Promise<number>

  • Removes members in a sorted set within a lexicographical range. Deletes the sorted set if all members were removed.

    • 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, start, stop, callback?): Promise<number>

  • Removes members in a sorted set within a range of indexes. Deletes the sorted set if all members were removed.

    • 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, min, max, callback?): Promise<number>

  • Removes members in a sorted set within a range of scores. Deletes the sorted set if all members were removed.

    • 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, start, stop, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns members in a sorted set within a range of indexes in reverse order.

    • 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
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrange(key, start, stop, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

zrevrangeBuffer

  • zrevrangeBuffer(key, start, stop, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrangeBuffer(key, start, stop, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

zrevrangebylex

  • zrevrangebylex(key, max, min, limitToken, offset, count, callback?): Promise<string[]>

  • Returns members in a sorted set within a lexicographical range in reverse order.

    • 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
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrevrangebylex(key, max, min, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

zrevrangebylexBuffer

  • zrevrangebylexBuffer(key, max, min, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrevrangebylexBuffer(key, max, min, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

zrevrangebyscore

  • zrevrangebyscore(key, max, min, withscores, limitToken, offset, count, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns members in a sorted set within a range of scores in reverse order.

    • 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
    • withscores: "WITHSCORES"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrangebyscore(key, max, min, limitToken, offset, count, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

  • zrevrangebyscore(key, max, min, withscores, callback?): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrangebyscore(key, max, min, callback?): Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • Optional callback: Callback<string[]>

    Returns Promise<string[]>

zrevrangebyscoreBuffer

  • zrevrangebyscoreBuffer(key, max, min, withscores, limitToken, offset, count, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrangebyscoreBuffer(key, max, min, limitToken, offset, count, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • limitToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • zrevrangebyscoreBuffer(key, max, min, withscores, callback?): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • Optional callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrangebyscoreBuffer(key, max, min, callback?): Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • Optional callback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

zrevrank

  • zrevrank(key, member, withscore, callback?): Promise<RespShape<Resp2<[rank: number, score: string]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the index of a member in a sorted set ordered by descending scores.

    • group: sorted-set
    • complexity: O(log(N))
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • withscore: "WITHSCORE"
    • Optional callback: Callback<RespShape<Resp2<[rank: number, score: string]>, Resp3<[rank: number, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<[rank: number, score: string]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zrevrank(key, member, callback?): Promise<number>

  • Parameters

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

    Returns Promise<number>

zrevrankBuffer

  • zrevrankBuffer(key, member, withscore, callback?): Promise<RespShape<Resp2<[rank: number, score: Buffer]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • withscore: "WITHSCORE"
    • Optional callback: Callback<RespShape<Resp2<[rank: number, score: Buffer]>, Resp3<[rank: number, score: number]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<[rank: number, score: Buffer]>, Resp3<[rank: number, score: number]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zscan

  • zscan(key, cursor, patternToken, pattern, countToken, count, callback?): Promise<[cursor: string, elements: string[]]>

  • Iterates over members and scores of a sorted set.

    • 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
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • zscan(key, cursor, countToken, count, callback?): 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[]]>

  • zscan(key, cursor, patternToken, pattern, callback?): 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[]]>

  • zscan(key, cursor, callback?): Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

zscanBuffer

  • zscanBuffer(key, cursor, patternToken, pattern, countToken, count, callback?): 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[]]>

  • zscanBuffer(key, cursor, countToken, count, callback?): 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[]]>

  • zscanBuffer(key, cursor, patternToken, pattern, callback?): 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[]]>

  • zscanBuffer(key, cursor, callback?): Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optional callback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

zscanBufferStream

zscanStream

zscore

  • zscore(key, member, callback?): Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the score of a 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<RespShape<Resp2<string>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<string>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zscoreBuffer

  • zscoreBuffer(key, member, callback?): Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optional callback: Callback<RespShape<Resp2<Buffer>, Resp3<number>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>

    Returns Promise<RespShape<Resp2<Buffer>, Resp3<number>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

zunion

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Returns the union of 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[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<string[]>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<string[]>, Resp3<[member: string, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

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

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • zunion(...args): Promise<string[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<string[]>

zunionBuffer

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
          mapping: ReplyMapping extends "resp3"
              ? "resp3"
              : "resp2";
          type: "default";
      }>>]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<RespShape<Resp2<Buffer[]>, Resp3<[member: Buffer, score: number][]>, {
        mapping: ReplyMapping extends "resp3"
            ? "resp3"
            : "resp2";
        type: "default";
    }>>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

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

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • zunionBuffer(...args): Promise<Buffer[]>

  • Parameters

    • Rest ...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<Buffer[]>

zunionstore

  • zunionstore(...args): Promise<number>

  • Stores the union of multiple sorted sets in a 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[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT", callback: Callback<number>]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    • Rest ...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", count: "COUNT"]

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

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

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

  • zunionstore(...args): Promise<number>

  • Parameters

    Returns Promise<number>

Static createClient

  • createClient(...args): Redis<"legacy">

  • Create a Redis instance. This is the same as new Redis() but is included for compatibility with node-redis.

    Parameters

    • Rest ...args: []

    Returns Redis<"legacy">

Settings

Member Visibility

Theme

On This Page

constructoroptionsstatusClusterCommandautoPipelineQueueSizemode_buildBatchContextaclaclBufferaddBuiltinCommandappendarcountardelardelrangeargetargetBufferargetrangeargetrangeBufferargrepargrepBufferarinfoarinfoBufferarinsertarlastitemsarlastitemsBufferarlenarmgetarmgetBufferarmsetarnextaroparopBufferarringarscanarscanBufferarseekarsetaskingauthbgrewriteaofbgrewriteaofBufferbgsavebitcountbitfieldbitfield_robitopbitposblmoveblmoveBufferblmovemblmovemBufferblmpopblmpopBufferblpopblpopBufferbrpopbrpopBufferbrpoplpushbrpoplpushBufferbzmpopbzpopmaxbzpopmaxBufferbzpopminbzpopminBuffercallcallBufferclientclientBufferclustercommandconfigconfigBufferconnectcopycreateBuiltinCommanddbsizedebugdecrdecrbydefineCommanddeldiscarddisconnectdumpdumpBufferduplicateechoechoBufferendevaleval_roevalshaevalsha_roexecexistsexpireexpireatexpiretimefailoverfcallfcall_roflushallflushdbfunctionfunctionBuffergeoaddgeodistgeodistBuffergeohashgeohashBuffergeoposgeoradiusgeoradius_rogeoradiusbymembergeoradiusbymember_rogeosearchgeosearchstoregetgetBuffergetBuiltinCommandsgetbitgetdelgetdelBuffergetexgetexBuffergetrangegetrangeBuffergetsetgetsetBufferhdelhellohexistshexpirehexpireathexpiretimehgethgetBufferhgetallhgetallBufferhgetdelhgetdelBufferhgetexhgetexBufferhimporthincrbyhincrbyfloathincrbyfloatBufferhkeyshkeysBufferhlenhmgethmgetBufferhmsethpersisthpexpirehpexpireathpexpiretimehpttlhrandfieldhrandfieldBufferhscanhscanBufferhscanBufferStreamhscanStreamhsethsetexhsetnxhstrlenhttlhvalshvalsBufferincrincrbyincrbyfloatincrexincrexBufferinfokeyskeysBufferlastsavelatencylcslindexlindexBufferlinsertllenlmovelmoveBufferlmovemlmovemBufferlmpoplmpopBufferlolwutlpoplpopBufferlposlpushlpushxlrangelrangeBufferlremlsetltrimmemorymgetmgetBuffermigratemodulemonitormovemsetmsetexmsetnxmultiobjectononcepersistpexpirepexpireatpexpiretimepfaddpfcountpfdebugpfmergepfselftestpingpingBufferpipelinepsetexpsubscribepsyncpttlpublishpubsubpunsubscribequitrandomkeyrandomkeyBufferreadonlyreadwriterenamerenamenxreplconfreplicaofresetrestorerestore-askingrolerpoprpopBufferrpoplpushrpoplpushBufferrpushrpushxsaddsavescanscanBufferscanBufferStreamscanStreamscardscriptsdiffsdiffBuffersdiffcardsdiffstoreselectsetsetBuffersetbitsetexsetnxsetrangeshutdownsintersinterBuffersintercardsinterstoresismemberslaveofslowlogsmemberssmembersBuffersmismembersmovesortsort_rospopspopBufferspublishsrandmembersrandmemberBuffersremsscansscanBuffersscanBufferStreamsscanStreamssubscribestrlensubscribesubstrsunionsunionBuffersunioncardsunionstoresunsubscribeswapdbsynctimetouchttltypeunlinkunsubscribeunwatchvaddvcardvdimvembvembBuffervgetattrvgetattrBuffervinfovinfoBuffervismembervlinksvlinksBuffervrandmembervrandmemberBuffervrangevrangeBuffervremvsetattrvsimvsimBufferwaitwatchxackxaddxaddBufferxautoclaimxclaimxdelxdelexxgroupxinfoxlenxnackxpendingxrangexrangeBufferxreadxreadBufferxreadgroupxreadgroupBufferxrevrangexrevrangeBufferxsetidxtrimzaddzaddBufferzcardzcountzdiffzdiffBufferzdiffstorezincrbyzincrbyBufferzinterzinterBufferzintercardzinterstorezlexcountzmpopzmscorezmscoreBufferzpopmaxzpopmaxBufferzpopminzpopminBufferzrandmemberzrandmemberBufferzrangezrangeBufferzrangebylexzrangebylexBufferzrangebyscorezrangebyscoreBufferzrangestorezrankzrankBufferzremzremrangebylexzremrangebyrankzremrangebyscorezrevrangezrevrangeBufferzrevrangebylexzrevrangebylexBufferzrevrangebyscorezrevrangebyscoreBufferzrevrankzrevrankBufferzscanzscanBufferzscanBufferStreamzscanStreamzscorezscoreBufferzunionzunionBufferzunionstorecreateClient