Skip to content
Permalink
main
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?

ioredis/lib/utils/RedisCommander.ts /
Jump to
Code definitions
ResultTypes Interface ChainableCommander Interface RedisCommander Interface call Method call Method call Method call Method callBuffer Method callBuffer Method callBuffer Method callBuffer Method acl Method acl Method acl Method acl Method acl Method aclBuffer Method acl Method aclBuffer Method acl Method aclBuffer Method acl Method aclBuffer Method acl Method aclBuffer Method acl Method aclBuffer Method acl Method acl Method aclBuffer Method acl Method acl Method acl Method acl Method acl Method acl Method acl Method acl Method acl Method aclBuffer Method acl Method aclBuffer Method append Method asking Method auth Method auth Method bgrewriteaof Method bgrewriteaofBuffer Method bgsave Method bgsave Method bitcount Method bitcount Method bitcount Method bitcount Method bitfield Method bitfield Method bitfield Method bitfield Method bitfield Method bitfield Method bitfield Method bitfield Method bitfield Method bitfield_ro Method bitfield_ro Method bitop Method bitop Method bitop Method bitop Method bitpos Method bitpos Method bitpos Method bitpos Method bitpos Method blmove Method blmoveBuffer Method blmove Method blmoveBuffer Method blmove Method blmoveBuffer Method blmove Method blmoveBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blmpop Method blmpopBuffer Method blpop Method blpopBuffer Method blpop Method blpopBuffer Method blpop Method blpopBuffer Method blpop Method blpopBuffer Method brpop Method brpopBuffer Method brpop Method brpopBuffer Method brpop Method brpopBuffer Method brpop Method brpopBuffer Method brpoplpush Method brpoplpushBuffer Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzmpop Method bzpopmax Method bzpopmaxBuffer Method bzpopmax Method bzpopmaxBuffer Method bzpopmax Method bzpopmaxBuffer Method bzpopmax Method bzpopmaxBuffer Method bzpopmin Method bzpopminBuffer Method bzpopmin Method bzpopminBuffer Method bzpopmin Method bzpopminBuffer Method bzpopmin Method bzpopminBuffer Method client Method client Method client Method clientBuffer Method client Method client Method client Method client Method clientBuffer Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method client Method clientBuffer Method client Method client Method client Method client Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method cluster Method command Method command Method command Method command Method command Method command Method command Method command Method command Method command Method command Method command Method command Method command Method config Method config Method config Method config Method config Method config Method config Method copy Method copy Method copy Method copy Method dbsize Method debug Method debug Method debug Method decr Method decrby Method del Method del Method del Method del Method discard Method dump Method dumpBuffer Method echo Method echoBuffer Method eval Method eval Method eval Method eval Method eval Method eval Method eval Method eval Method eval Method eval_ro Method eval_ro Method evalsha Method evalsha Method evalsha Method evalsha Method evalsha Method evalsha Method evalsha Method evalsha Method evalsha Method evalsha_ro Method evalsha_ro Method exec Method exists Method exists Method exists Method exists Method expire Method expire Method expire Method expire Method expire Method expireat Method expireat Method expireat Method expireat Method expireat Method expiretime Method failover Method failover Method failover Method failover Method failover Method failover Method failover Method failover Method failover Method failover Method failover Method failover Method fcall Method fcall Method fcall_ro Method fcall_ro Method flushall Method flushall Method flushall Method flushdb Method flushdb Method flushdb Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method function Method functionBuffer Method function Method function Method function Method function Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method functionBuffer Method function Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geoadd Method geodist Method geodistBuffer Method geodist Method geodistBuffer Method geodist Method geodistBuffer Method geodist Method geodistBuffer Method geodist Method geodistBuffer Method geohash Method geohashBuffer Method geohash Method geohashBuffer Method geohash Method geohashBuffer Method geohash Method geohashBuffer Method geopos Method geopos Method geopos Method geopos Method georadius Method georadius Method georadius_ro Method georadius_ro Method georadiusbymember Method georadiusbymember Method georadiusbymember_ro Method georadiusbymember_ro Method geosearch Method geosearch Method geosearchstore Method geosearchstore Method get Method getBuffer Method getbit Method getdel Method getdelBuffer Method getex Method getexBuffer Method getex Method getexBuffer Method getex Method getexBuffer Method getex Method getexBuffer Method getex Method getexBuffer Method getex Method getexBuffer Method getrange Method getrangeBuffer Method getset Method getsetBuffer Method hdel Method hdel Method hello Method hello Method hello Method hello Method hello Method hexists Method hget Method hgetBuffer Method hgetall Method hgetallBuffer Method hincrby Method hincrbyfloat Method hincrbyfloatBuffer Method hkeys Method hkeysBuffer Method hlen Method hmget Method hmgetBuffer Method hmget Method hmgetBuffer Method hmset Method hmset Method hmset Method hmset Method hrandfield Method hrandfieldBuffer Method hrandfield Method hrandfieldBuffer Method hrandfield Method hrandfieldBuffer Method hscan Method hscanBuffer Method hscan Method hscanBuffer Method hscan Method hscanBuffer Method hscan Method hscanBuffer Method hset Method hset Method hset Method hset Method hsetnx Method hstrlen Method hvals Method hvalsBuffer Method incr Method incrby Method incrbyfloat Method info Method info Method info Method keys Method keysBuffer Method lastsave Method latency Method latency Method latency Method latency Method latency Method latency Method latency Method latency Method latency Method latency Method latency Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lcs Method lindex Method lindexBuffer Method linsert Method linsert Method llen Method lmove Method lmoveBuffer Method lmove Method lmoveBuffer Method lmove Method lmoveBuffer Method lmove Method lmoveBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lmpop Method lmpopBuffer Method lolwut Method lolwut Method lpop Method lpopBuffer Method lpop Method lpopBuffer Method lpos Method lpos Method lpos Method lpos Method lpos Method lpos Method lpos Method lpos Method lpush Method lpush Method lpushx Method lpushx Method lrange Method lrangeBuffer Method lrem Method lset Method ltrim Method memory Method memory Method memory Method memory Method memory Method memory Method memory Method mget Method mgetBuffer Method mget Method mgetBuffer Method mget Method mgetBuffer Method mget Method mgetBuffer Method migrate Method migrate Method module Method module Method module Method module Method module Method module Method module Method module Method module Method module Method module Method module Method module Method move Method mset Method mset Method mset Method mset Method msetnx Method msetnx Method msetnx Method msetnx Method object Method object Method object Method object Method object Method persist Method pexpire Method pexpire Method pexpire Method pexpire Method pexpire Method pexpireat Method pexpireat Method pexpireat Method pexpireat Method pexpireat Method pexpiretime Method pfadd Method pfadd Method pfadd Method pfcount Method pfcount Method pfcount Method pfcount Method pfdebug Method pfmerge Method pfmerge Method pfmerge Method pfmerge Method pfselftest Method ping Method ping Method pingBuffer Method psetex Method psubscribe Method psubscribe Method psync Method pttl Method publish Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method pubsub Method punsubscribe Method punsubscribe Method punsubscribe Method quit Method randomkey Method randomkeyBuffer Method readonly Method readwrite Method rename Method renamenx Method replconf Method replicaof Method reset Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method restore Method role Method rpop Method rpopBuffer Method rpop Method rpopBuffer Method rpoplpush Method rpoplpushBuffer Method rpush Method rpush Method rpushx Method rpushx Method sadd Method sadd Method sadd Method sadd Method save Method scan Method scanBuffer Method scan Method scanBuffer Method scan Method scanBuffer Method scan Method scanBuffer Method scan Method scanBuffer Method scan Method scanBuffer Method scan Method scanBuffer Method scan Method scanBuffer Method scard Method script Method script Method script Method script Method script Method script Method script Method script Method script Method script Method script Method sdiff Method sdiffBuffer Method sdiff Method sdiffBuffer Method sdiff Method sdiffBuffer Method sdiff Method sdiffBuffer Method sdiffstore Method sdiffstore Method sdiffstore Method sdiffstore Method select Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method set Method set Method setBuffer Method setbit Method setex Method setnx Method setrange Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method shutdown Method sinter Method sinterBuffer Method sinter Method sinterBuffer Method sinter Method sinterBuffer Method sinter Method sinterBuffer Method sintercard Method sintercard Method sintercard Method sintercard Method sintercard Method sintercard Method sintercard Method sintercard Method sinterstore Method sinterstore Method sinterstore Method sinterstore Method sismember Method slaveof Method slowlog Method slowlog Method slowlog Method slowlog Method slowlog Method smembers Method smembersBuffer Method smismember Method smismember Method smismember Method smismember Method smove Method sort Method sort Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method sort_ro Method spop Method spopBuffer Method spop Method spopBuffer Method spublish Method srandmember Method srandmemberBuffer Method srandmember Method srandmemberBuffer Method srem Method srem Method srem Method srem Method sscan Method sscanBuffer Method sscan Method sscanBuffer Method sscan Method sscanBuffer Method sscan Method sscanBuffer Method ssubscribe Method ssubscribe Method strlen Method subscribe Method subscribe Method substr Method sunion Method sunionBuffer Method sunion Method sunionBuffer Method sunion Method sunionBuffer Method sunion Method sunionBuffer Method sunionstore Method sunionstore Method sunionstore Method sunionstore Method sunsubscribe Method sunsubscribe Method sunsubscribe Method swapdb Method sync Method time Method touch Method touch Method touch Method touch Method ttl Method type Method unlink Method unlink Method unlink Method unlink Method unsubscribe Method unsubscribe Method unsubscribe Method unwatch Method wait Method watch Method watch Method watch Method watch Method xack Method xack Method xadd Method xaddBuffer Method xadd Method xaddBuffer Method xautoclaim Method xautoclaim Method xautoclaim Method xautoclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xclaim Method xdel Method xdel Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xgroup Method xinfo Method xinfo Method xinfo Method xinfo Method xinfo Method xinfo Method xlen Method xpending Method xpending Method xpending Method xpending Method xpending Method xrange Method xrangeBuffer Method xrange Method xrangeBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xread Method xreadBuffer Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xreadgroup Method xrevrange Method xrevrangeBuffer Method xrevrange Method xrevrangeBuffer Method xsetid Method xsetid Method xsetid Method xsetid Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method xtrim Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zadd Method zadd Method zadd Method zaddBuffer Method zadd Method zaddBuffer Method zcard Method zcount Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiff Method zdiffBuffer Method zdiffstore Method zdiffstore Method zdiffstore Method zdiffstore Method zincrby Method zincrbyBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zinter Method zinterBuffer Method zintercard Method zintercard Method zintercard Method zintercard Method zintercard Method zintercard Method zintercard Method zintercard Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zinterstore Method zlexcount Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmpop Method zmscore Method zmscoreBuffer Method zmscore Method zmscoreBuffer Method zmscore Method zmscoreBuffer Method zmscore Method zmscoreBuffer Method zpopmax Method zpopmaxBuffer Method zpopmax Method zpopmaxBuffer Method zpopmin Method zpopminBuffer Method zpopmin Method zpopminBuffer Method zrandmember Method zrandmemberBuffer Method zrandmember Method zrandmemberBuffer Method zrandmember Method zrandmemberBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrange Method zrangeBuffer Method zrangebylex Method zrangebylexBuffer Method zrangebylex Method zrangebylexBuffer Method zrangebyscore Method zrangebyscoreBuffer Method zrangebyscore Method zrangebyscoreBuffer Method zrangebyscore Method zrangebyscoreBuffer Method zrangebyscore Method zrangebyscoreBuffer Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrangestore Method zrank Method zrem Method zrem Method zrem Method zrem Method zremrangebylex Method zremrangebyrank Method zremrangebyscore Method zrevrange Method zrevrangeBuffer Method zrevrange Method zrevrangeBuffer Method zrevrangebylex Method zrevrangebylexBuffer Method zrevrangebylex Method zrevrangebylexBuffer Method zrevrangebyscore Method zrevrangebyscoreBuffer Method zrevrangebyscore Method zrevrangebyscoreBuffer Method zrevrangebyscore Method zrevrangebyscoreBuffer Method zrevrangebyscore Method zrevrangebyscoreBuffer Method zrevrank Method zscan Method zscanBuffer Method zscan Method zscanBuffer Method zscan Method zscanBuffer Method zscan Method zscanBuffer Method zscore Method zscoreBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunion Method zunionBuffer Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method zunionstore Method
Code navigation index up-to-date

Go to file
  • Go to file
  • Copy path
  • Copy permalink
 
 
Cannot retrieve contributors at this time
14890 lines (14534 sloc) 382 KB
Raw Blame
Open in GitHub Desktop
/**
* This file is generated by @ioredis/interface-generator.
* Don't edit it manually. Instead, run `npm run generate` to update
* this file.
*/
import { Callback } from "../types";
export type RedisKey = string | Buffer;
export type RedisValue = string | Buffer | number;
// Inspired by https://github.com/mmkal/handy-redis/blob/main/src/generated/interface.ts.
// Should be fixed with https://github.com/Microsoft/TypeScript/issues/1213
// eslint-disable-next-line @typescript-eslint/no-unused-vars
export interface ResultTypes<Result, Context> {
default: Promise<Result>;
pipeline: ChainableCommander;
}
export interface ChainableCommander
extends RedisCommander<{ type: "pipeline" }> {
length: number;
}
export type ClientContext = { type: keyof ResultTypes<unknown, unknown> };
export type Result<T, Context extends ClientContext> =
// prettier-break
ResultTypes<T, Context>[Context["type"]];
interface RedisCommander<Context extends ClientContext = { type: "default" }> {
/**
* 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.
*
* ```ts
* redis.call('set', 'foo', 'bar');
* redis.call('get', 'foo', (err, value) => {
* // value === 'bar'
* });
* ```
*/
call(command: string, callback?: Callback<unknown>): Result<unknown, Context>;
call(
command: string,
args: (string | Buffer | number)[],
callback?: Callback<unknown>
): Result<unknown, Context>;
call(
...args: [
command: string,
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
call(
...args: [command: string, ...args: (string | Buffer | number)[]]
): Result<unknown, Context>;
callBuffer(
command: string,
callback?: Callback<unknown>
): Result<unknown, Context>;
callBuffer(
command: string,
args: (string | Buffer | number)[],
callback?: Callback<unknown>
): Result<unknown, Context>;
callBuffer(
...args: [
command: string,
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
callBuffer(
...args: [command: string, ...args: (string | Buffer | number)[]]
): Result<unknown, Context>;
/**
* List the ACL categories or the commands inside a category
* - _group_: server
* - _complexity_: O(1) since the categories and commands are a fixed set.
* - _since_: 6.0.0
*/
acl(
subcommand: "CAT",
callback?: Callback<unknown>
): Result<unknown, Context>;
acl(
subcommand: "CAT",
categoryname: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Remove the specified ACL users and the associated rules
* - _group_: server
* - _complexity_: O(1) amortized time considering the typical user.
* - _since_: 6.0.0
*/
acl(
...args: [
subcommand: "DELUSER",
...usernames: (string | Buffer)[],
callback: Callback<number>
]
): Result<number, Context>;
acl(
...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]
): Result<number, Context>;
/**
* Returns whether the user can execute the given command without executing the command.
* - _group_: server
* - _complexity_: O(1).
* - _since_: 7.0.0
*/
acl(
subcommand: "DRYRUN",
username: string | Buffer,
command: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
aclBuffer(
subcommand: "DRYRUN",
username: string | Buffer,
command: string | Buffer,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
acl(
...args: [
subcommand: "DRYRUN",
username: string | Buffer,
command: string | Buffer,
...args: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
aclBuffer(
...args: [
subcommand: "DRYRUN",
username: string | Buffer,
command: string | Buffer,
...args: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
acl(
...args: [
subcommand: "DRYRUN",
username: string | Buffer,
command: string | Buffer,
...args: (string | Buffer | number)[]
]
): Result<string, Context>;
aclBuffer(
...args: [
subcommand: "DRYRUN",
username: string | Buffer,
command: string | Buffer,
...args: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
/**
* Generate a pseudorandom secure password to use for ACL users
* - _group_: server
* - _complexity_: O(1)
* - _since_: 6.0.0
*/
acl(
subcommand: "GENPASS",
callback?: Callback<string>
): Result<string, Context>;
aclBuffer(
subcommand: "GENPASS",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
acl(
subcommand: "GENPASS",
bits: number | string,
callback?: Callback<string>
): Result<string, Context>;
aclBuffer(
subcommand: "GENPASS",
bits: number | string,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Get the rules for a specific ACL user
* - _group_: server
* - _complexity_: O(N). Where N is the number of password, command and pattern rules that the user has.
* - _since_: 6.0.0
*/
acl(
subcommand: "GETUSER",
username: string | Buffer,
callback?: Callback<string[] | null>
): Result<string[] | null, Context>;
aclBuffer(
subcommand: "GETUSER",
username: string | Buffer,
callback?: Callback<Buffer[] | null>
): Result<Buffer[] | null, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 6.0.0
*/
acl(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* List the current ACL rules in ACL config file format
* - _group_: server
* - _complexity_: O(N). Where N is the number of configured users.
* - _since_: 6.0.0
*/
acl(
subcommand: "LIST",
callback?: Callback<string[]>
): Result<string[], Context>;
aclBuffer(
subcommand: "LIST",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Reload the ACLs from the configured ACL file
* - _group_: server
* - _complexity_: O(N). Where N is the number of configured users.
* - _since_: 6.0.0
*/
acl(subcommand: "LOAD", callback?: Callback<"OK">): Result<"OK", Context>;
/**
* List latest events denied because of ACLs in place
* - _group_: server
* - _complexity_: O(N) with N being the number of entries shown.
* - _since_: 6.0.0
*/
acl(
subcommand: "LOG",
callback?: Callback<unknown>
): Result<unknown, Context>;
acl(
subcommand: "LOG",
count: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
acl(
subcommand: "LOG",
reset: "RESET",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Save the current ACL rules in the configured ACL file
* - _group_: server
* - _complexity_: O(N). Where N is the number of configured users.
* - _since_: 6.0.0
*/
acl(subcommand: "SAVE", callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Modify or create the rules for a specific ACL user
* - _group_: server
* - _complexity_: O(N). Where N is the number of rules provided.
* - _since_: 6.0.0
*/
acl(
subcommand: "SETUSER",
username: string | Buffer,
callback?: Callback<"OK">
): Result<"OK", Context>;
acl(
...args: [
subcommand: "SETUSER",
username: string | Buffer,
...rules: (string | Buffer)[],
callback: Callback<"OK">
]
): Result<"OK", Context>;
acl(
...args: [
subcommand: "SETUSER",
username: string | Buffer,
...rules: (string | Buffer)[]
]
): Result<"OK", Context>;
/**
* List the username of all the configured ACL rules
* - _group_: server
* - _complexity_: O(N). Where N is the number of configured users.
* - _since_: 6.0.0
*/
acl(
subcommand: "USERS",
callback?: Callback<string[]>
): Result<string[], Context>;
aclBuffer(
subcommand: "USERS",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Return the name of the user associated to the current connection
* - _group_: server
* - _complexity_: O(1)
* - _since_: 6.0.0
*/
acl(
subcommand: "WHOAMI",
callback?: Callback<string>
): Result<string, Context>;
aclBuffer(
subcommand: "WHOAMI",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Append a value to a key
* - _group_: string
* - _complexity_: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.
* - _since_: 2.0.0
*/
append(
key: RedisKey,
value: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Sent by cluster clients after an -ASK redirect
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
asking(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Authenticate to the server
* - _group_: connection
* - _complexity_: O(N) where N is the number of passwords defined for the user
* - _since_: 1.0.0
*/
auth(
password: string | Buffer,
callback?: Callback<"OK">
): Result<"OK", Context>;
auth(
username: string | Buffer,
password: string | Buffer,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Asynchronously rewrite the append-only file
* - _group_: server
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
bgrewriteaof(callback?: Callback<string>): Result<string, Context>;
bgrewriteaofBuffer(callback?: Callback<Buffer>): Result<Buffer, Context>;
/**
* Asynchronously save the dataset to disk
* - _group_: server
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
bgsave(callback?: Callback<"OK">): Result<"OK", Context>;
bgsave(
schedule: "SCHEDULE",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Count set bits in a string
* - _group_: bitmap
* - _complexity_: O(N)
* - _since_: 2.6.0
*/
bitcount(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
bitcount(
key: RedisKey,
start: number | string,
end: number | string,
callback?: Callback<number>
): Result<number, Context>;
bitcount(
key: RedisKey,
start: number | string,
end: number | string,
byte: "BYTE",
callback?: Callback<number>
): Result<number, Context>;
bitcount(
key: RedisKey,
start: number | string,
end: number | string,
bit: "BIT",
callback?: Callback<number>
): Result<number, Context>;
/**
* Perform arbitrary bitfield integer operations on strings
* - _group_: bitmap
* - _complexity_: O(1) for each subcommand specified
* - _since_: 3.2.0
*/
bitfield(
key: RedisKey,
encodingOffsetToken: "GET",
encoding: string | Buffer,
offset: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
encodingOffsetValueToken: "SET",
encoding: string | Buffer,
offset: number | string,
value: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
encodingOffsetIncrementToken: "INCRBY",
encoding: string | Buffer,
offset: number | string,
increment: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
overflow: "OVERFLOW",
wrap: "WRAP",
encodingOffsetValueToken: "SET",
encoding: string | Buffer,
offset: number | string,
value: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
overflow: "OVERFLOW",
wrap: "WRAP",
encodingOffsetIncrementToken: "INCRBY",
encoding: string | Buffer,
offset: number | string,
increment: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
overflow: "OVERFLOW",
sat: "SAT",
encodingOffsetValueToken: "SET",
encoding: string | Buffer,
offset: number | string,
value: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
overflow: "OVERFLOW",
sat: "SAT",
encodingOffsetIncrementToken: "INCRBY",
encoding: string | Buffer,
offset: number | string,
increment: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
overflow: "OVERFLOW",
fail: "FAIL",
encodingOffsetValueToken: "SET",
encoding: string | Buffer,
offset: number | string,
value: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
bitfield(
key: RedisKey,
overflow: "OVERFLOW",
fail: "FAIL",
encodingOffsetIncrementToken: "INCRBY",
encoding: string | Buffer,
offset: number | string,
increment: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD
* - _group_: bitmap
* - _complexity_: O(1) for each subcommand specified
* - _since_: 6.0.0
*/
bitfield_ro(
...args: [
key: RedisKey,
encodingOffsetToken: "GET",
...encodingOffsets: (string | Buffer | number)[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
bitfield_ro(
...args: [
key: RedisKey,
encodingOffsetToken: "GET",
...encodingOffsets: (string | Buffer | number)[]
]
): Result<unknown[], Context>;
/**
* Perform bitwise operations between strings
* - _group_: bitmap
* - _complexity_: O(N)
* - _since_: 2.6.0
*/
bitop(
...args: [
operation: string | Buffer,
destkey: RedisKey,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
bitop(
...args: [
operation: string | Buffer,
destkey: RedisKey,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
bitop(
...args: [
operation: string | Buffer,
destkey: RedisKey,
...keys: RedisKey[]
]
): Result<number, Context>;
bitop(
...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[]]
): Result<number, Context>;
/**
* Find first bit set or clear in a string
* - _group_: bitmap
* - _complexity_: O(N)
* - _since_: 2.8.7
*/
bitpos(
key: RedisKey,
bit: number | string,
callback?: Callback<number>
): Result<number, Context>;
bitpos(
key: RedisKey,
bit: number | string,
start: number | string,
callback?: Callback<number>
): Result<number, Context>;
bitpos(
key: RedisKey,
bit: number | string,
start: number | string,
end: number | string,
callback?: Callback<number>
): Result<number, Context>;
bitpos(
key: RedisKey,
bit: number | string,
start: number | string,
end: number | string,
byte: "BYTE",
callback?: Callback<number>
): Result<number, Context>;
bitpos(
key: RedisKey,
bit: number | string,
start: number | string,
end: number | string,
bit1: "BIT",
callback?: Callback<number>
): Result<number, Context>;
/**
* Pop an element from a list, push it to another list and return it; or block until one is available
* - _group_: list
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
blmove(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
left1: "LEFT",
timeout: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
blmoveBuffer(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
left1: "LEFT",
timeout: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
blmove(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
right: "RIGHT",
timeout: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
blmoveBuffer(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
right: "RIGHT",
timeout: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
blmove(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
left: "LEFT",
timeout: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
blmoveBuffer(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
left: "LEFT",
timeout: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
blmove(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
right1: "RIGHT",
timeout: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
blmoveBuffer(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
right1: "RIGHT",
timeout: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Pop elements from a list, or block until one is available
* - _group_: list
* - _complexity_: O(N+M) where N is the number of provided keys and M is the number of elements returned.
* - _since_: 7.0.0
*/
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT"
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT"
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT"
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT"
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT"
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT"
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT"
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT"
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
blmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
blmpopBuffer(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
/**
* Remove and get the first element in a list, or block until one is available
* - _group_: list
* - _complexity_: O(N) where N is the number of provided keys.
* - _since_: 2.0.0
*/
blpop(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[string, string] | null>
]
): Result<[string, string] | null, Context>;
blpopBuffer(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[Buffer, Buffer] | null>
]
): Result<[Buffer, Buffer] | null, Context>;
blpop(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[string, string] | null>
]
): Result<[string, string] | null, Context>;
blpopBuffer(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[Buffer, Buffer] | null>
]
): Result<[Buffer, Buffer] | null, Context>;
blpop(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[string, string] | null, Context>;
blpopBuffer(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[Buffer, Buffer] | null, Context>;
blpop(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[string, string] | null, Context>;
blpopBuffer(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[Buffer, Buffer] | null, Context>;
/**
* Remove and get the last element in a list, or block until one is available
* - _group_: list
* - _complexity_: O(N) where N is the number of provided keys.
* - _since_: 2.0.0
*/
brpop(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[string, string] | null>
]
): Result<[string, string] | null, Context>;
brpopBuffer(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[Buffer, Buffer] | null>
]
): Result<[Buffer, Buffer] | null, Context>;
brpop(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[string, string] | null>
]
): Result<[string, string] | null, Context>;
brpopBuffer(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[Buffer, Buffer] | null>
]
): Result<[Buffer, Buffer] | null, Context>;
brpop(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[string, string] | null, Context>;
brpopBuffer(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[Buffer, Buffer] | null, Context>;
brpop(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[string, string] | null, Context>;
brpopBuffer(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[Buffer, Buffer] | null, Context>;
/**
* Pop an element from a list, push it to another list and return it; or block until one is available
* - _group_: list
* - _complexity_: O(1)
* - _since_: 2.2.0
*/
brpoplpush(
source: RedisKey,
destination: RedisKey,
timeout: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
brpoplpushBuffer(
source: RedisKey,
destination: RedisKey,
timeout: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Remove and return members with scores in a sorted set or block until one is available
* - _group_: sorted-set
* - _complexity_: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
* - _since_: 7.0.0
*/
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
min: "MIN",
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
min: "MIN",
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
min: "MIN"
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
min: "MIN"
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
max: "MAX",
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
max: "MAX",
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
max: "MAX"
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
max: "MAX"
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
...keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
bzmpop(
...args: [
timeout: number | string,
numkeys: number | string,
keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
/**
* Remove and return the member with the highest score from one or more sorted sets, or block until one is available
* - _group_: sorted-set
* - _complexity_: O(log(N)) with N being the number of elements in the sorted set.
* - _since_: 5.0.0
*/
bzpopmax(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: string, member: string, score: string] | null>
]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopmaxBuffer(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: Buffer, member: Buffer, score: Buffer] | null>
]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
bzpopmax(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: string, member: string, score: string] | null>
]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopmaxBuffer(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: Buffer, member: Buffer, score: Buffer] | null>
]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
bzpopmax(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopmaxBuffer(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
bzpopmax(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopmaxBuffer(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
/**
* Remove and return the member with the lowest score from one or more sorted sets, or block until one is available
* - _group_: sorted-set
* - _complexity_: O(log(N)) with N being the number of elements in the sorted set.
* - _since_: 5.0.0
*/
bzpopmin(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: string, member: string, score: string] | null>
]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopminBuffer(
...args: [
...keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: Buffer, member: Buffer, score: Buffer] | null>
]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
bzpopmin(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: string, member: string, score: string] | null>
]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopminBuffer(
...args: [
keys: RedisKey[],
timeout: number | string,
callback: Callback<[key: Buffer, member: Buffer, score: Buffer] | null>
]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
bzpopmin(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopminBuffer(
...args: [...keys: RedisKey[], timeout: number | string]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
bzpopmin(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[key: string, member: string, score: string] | null, Context>;
bzpopminBuffer(
...args: [keys: RedisKey[], timeout: number | string]
): Result<[key: Buffer, member: Buffer, score: Buffer] | null, Context>;
/**
* Instruct the server about tracking or not keys in the next request
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 6.0.0
*/
client(
subcommand: "CACHING",
yes: "YES",
callback?: Callback<"OK">
): Result<"OK", Context>;
client(
subcommand: "CACHING",
no: "NO",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Get the current connection name
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 2.6.9
*/
client(
subcommand: "GETNAME",
callback?: Callback<string | null>
): Result<string | null, Context>;
clientBuffer(
subcommand: "GETNAME",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Get tracking notifications redirection client ID if any
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 6.0.0
*/
client(
subcommand: "GETREDIR",
callback?: Callback<number>
): Result<number, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
client(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Returns the client ID for the current connection
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
client(
subcommand: "ID",
callback?: Callback<number>
): Result<number, Context>;
/**
* Returns information about the current client connection.
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
client(
subcommand: "INFO",
callback?: Callback<string>
): Result<string, Context>;
clientBuffer(
subcommand: "INFO",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Kill the connection of a client
* - _group_: connection
* - _complexity_: O(N) where N is the number of client connections
* - _since_: 2.4.0
*/
client(
...args: [
subcommand: "KILL",
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [subcommand: "KILL", ...args: RedisValue[]]
): Result<unknown, Context>;
/**
* Get the list of client connections
* - _group_: connection
* - _complexity_: O(N) where N is the number of client connections
* - _since_: 2.4.0
*/
client(
subcommand: "LIST",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
idToken: "ID",
...clientIds: (number | string)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
idToken: "ID",
...clientIds: (number | string)[]
]
): Result<unknown, Context>;
client(
subcommand: "LIST",
type: "TYPE",
normal: "NORMAL",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
normal: "NORMAL",
idToken: "ID",
...clientIds: (number | string)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
normal: "NORMAL",
idToken: "ID",
...clientIds: (number | string)[]
]
): Result<unknown, Context>;
client(
subcommand: "LIST",
type: "TYPE",
master: "MASTER",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
master: "MASTER",
idToken: "ID",
...clientIds: (number | string)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
master: "MASTER",
idToken: "ID",
...clientIds: (number | string)[]
]
): Result<unknown, Context>;
client(
subcommand: "LIST",
type: "TYPE",
replica: "REPLICA",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
replica: "REPLICA",
idToken: "ID",
...clientIds: (number | string)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
replica: "REPLICA",
idToken: "ID",
...clientIds: (number | string)[]
]
): Result<unknown, Context>;
client(
subcommand: "LIST",
type: "TYPE",
pubsub: "PUBSUB",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
pubsub: "PUBSUB",
idToken: "ID",
...clientIds: (number | string)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [
subcommand: "LIST",
type: "TYPE",
pubsub: "PUBSUB",
idToken: "ID",
...clientIds: (number | string)[]
]
): Result<unknown, Context>;
/**
* Set client eviction mode for the current connection
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
client(
subcommand: "NO-EVICT",
on: "ON",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
subcommand: "NO-EVICT",
off: "OFF",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Stop processing commands from clients for some time
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 2.9.50
*/
client(
subcommand: "PAUSE",
timeout: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
client(
subcommand: "PAUSE",
timeout: number | string,
write: "WRITE",
callback?: Callback<"OK">
): Result<"OK", Context>;
client(
subcommand: "PAUSE",
timeout: number | string,
all: "ALL",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Instruct the server whether to reply to commands
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 3.2.0
*/
client(
subcommand: "REPLY",
on: "ON",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
subcommand: "REPLY",
off: "OFF",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
subcommand: "REPLY",
skip: "SKIP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Set the current connection name
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 2.6.9
*/
client(
subcommand: "SETNAME",
connectionName: string | Buffer,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Enable or disable server assisted client side caching support
* - _group_: connection
* - _complexity_: O(1). Some options may introduce additional complexity.
* - _since_: 6.0.0
*/
client(
...args: [
subcommand: "TRACKING",
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
client(
...args: [subcommand: "TRACKING", ...args: RedisValue[]]
): Result<unknown, Context>;
/**
* Return information about server assisted client side caching for the current connection
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
client(
subcommand: "TRACKINGINFO",
callback?: Callback<string>
): Result<string, Context>;
clientBuffer(
subcommand: "TRACKINGINFO",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Unblock a client blocked in a blocking command from a different connection
* - _group_: connection
* - _complexity_: O(log N) where N is the number of client connections
* - _since_: 5.0.0
*/
client(
subcommand: "UNBLOCK",
clientId: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
subcommand: "UNBLOCK",
clientId: number | string,
timeout: "TIMEOUT",
callback?: Callback<unknown>
): Result<unknown, Context>;
client(
subcommand: "UNBLOCK",
clientId: number | string,
error: "ERROR",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Resume processing of clients that were paused
* - _group_: connection
* - _complexity_: O(N) Where N is the number of paused clients
* - _since_: 6.2.0
*/
client(
subcommand: "UNPAUSE",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Assign new hash slots to receiving node
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of hash slot arguments
* - _since_: 3.0.0
*/
cluster(
...args: [
subcommand: "ADDSLOTS",
...slots: (number | string)[],
callback: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [
subcommand: "ADDSLOTS",
slots: (number | string)[],
callback: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [subcommand: "ADDSLOTS", ...slots: (number | string)[]]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [subcommand: "ADDSLOTS", slots: (number | string)[]]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
/**
* Assign new hash slots to receiving node
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of the slots between the start slot and end slot arguments.
* - _since_: 7.0.0
*/
cluster(
...args: [
subcommand: "ADDSLOTSRANGE",
...startSlotEndSlots: (string | number)[],
callback: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [
subcommand: "ADDSLOTSRANGE",
...startSlotEndSlots: (string | number)[]
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
/**
* Advance the cluster config epoch
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "BUMPEPOCH",
callback?: Callback<"BUMPED" | "STILL">
): Result<"BUMPED" | "STILL", Context>;
/**
* Return the number of failure reports active for a given node
* - _group_: cluster
* - _complexity_: O(N) where N is the number of failure reports
* - _since_: 3.0.0
*/
cluster(
subcommand: "COUNT-FAILURE-REPORTS",
nodeId: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Return the number of local keys in the specified hash slot
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "COUNTKEYSINSLOT",
slot: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Set hash slots as unbound in receiving node
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of hash slot arguments
* - _since_: 3.0.0
*/
cluster(
...args: [
subcommand: "DELSLOTS",
...slots: (number | string)[],
callback: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [
subcommand: "DELSLOTS",
slots: (number | string)[],
callback: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [subcommand: "DELSLOTS", ...slots: (number | string)[]]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [subcommand: "DELSLOTS", slots: (number | string)[]]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
/**
* Set hash slots as unbound in receiving node
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of the slots between the start slot and end slot arguments.
* - _since_: 7.0.0
*/
cluster(
...args: [
subcommand: "DELSLOTSRANGE",
...startSlotEndSlots: (string | number)[],
callback: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
cluster(
...args: [
subcommand: "DELSLOTSRANGE",
...startSlotEndSlots: (string | number)[]
]
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
/**
* Forces a replica to perform a manual failover of its master.
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "FAILOVER",
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "FAILOVER",
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "FAILOVER",
takeover: "TAKEOVER",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Delete a node's own slots information
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "FLUSHSLOTS",
callback?: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
/**
* Remove a node from the nodes table
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "FORGET",
nodeId: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Return local key names in the specified hash slot
* - _group_: cluster
* - _complexity_: O(log(N)) where N is the number of requested keys
* - _since_: 3.0.0
*/
cluster(
subcommand: "GETKEYSINSLOT",
slot: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
/**
* Show helpful text about the different subcommands
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
cluster(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Provides info about Redis Cluster node state
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "INFO",
callback?: Callback<string>
): Result<string, Context>;
/**
* Returns the hash slot of the specified key
* - _group_: cluster
* - _complexity_: O(N) where N is the number of bytes in the key
* - _since_: 3.0.0
*/
cluster(
subcommand: "KEYSLOT",
key: string | Buffer,
callback?: Callback<number>
): Result<number, Context>;
/**
* Returns a list of all TCP links to and from peer nodes in cluster
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of Cluster nodes
* - _since_: 7.0.0
*/
cluster(
subcommand: "LINKS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Force a node cluster to handshake with another node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "MEET",
ip: string | Buffer,
port: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Return the node id
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "MYID",
callback?: Callback<string>
): Result<string, Context>;
/**
* Get Cluster config for the node
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of Cluster nodes
* - _since_: 3.0.0
*/
cluster(
subcommand: "NODES",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* List replica nodes of the specified master node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
cluster(
subcommand: "REPLICAS",
nodeId: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Reconfigure a node as a replica of the specified master node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "REPLICATE",
nodeId: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Reset a Redis Cluster node
* - _group_: cluster
* - _complexity_: O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.
* - _since_: 3.0.0
*/
cluster(
subcommand: "RESET",
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "RESET",
hard: "HARD",
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "RESET",
soft: "SOFT",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Forces the node to save cluster state on disk
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "SAVECONFIG",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Set the configuration epoch in a new node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "SET-CONFIG-EPOCH",
configEpoch: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Bind a hash slot to a specific node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "SETSLOT",
slot: number | string,
nodeIdToken: "IMPORTING",
nodeId: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "SETSLOT",
slot: number | string,
nodeIdToken: "MIGRATING",
nodeId: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "SETSLOT",
slot: number | string,
nodeIdToken: "NODE",
nodeId: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
cluster(
subcommand: "SETSLOT",
slot: number | string,
stable: "STABLE",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Get array of cluster slots to node mappings
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of cluster nodes
* - _since_: 7.0.0
*/
cluster(
subcommand: "SHARDS",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* List replica nodes of the specified master node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
cluster(
subcommand: "SLAVES",
nodeId: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get array of Cluster slot to node mappings
* - _group_: cluster
* - _complexity_: O(N) where N is the total number of Cluster nodes
* - _since_: 3.0.0
*/
cluster(
subcommand: "SLOTS",
callback?: Callback<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [
host: string,
port: number,
nodeId: string,
info: unknown[]
][]
][]
>
): Result<
[
startSlotRange: number,
endSlotRange: number,
...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]
][],
Context
>;
/**
* Get total number of Redis commands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
command(
subcommand: "COUNT",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Get array of specific Redis command documentation
* - _group_: server
* - _complexity_: O(N) where N is the number of commands to look up
* - _since_: 7.0.0
*/
command(
subcommand: "DOCS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
command(
...args: [
subcommand: "DOCS",
...commandNames: (string | Buffer)[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
command(
...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]
): Result<unknown[], Context>;
/**
* Extract keys given a full Redis command
* - _group_: server
* - _complexity_: O(N) where N is the number of arguments to the command
* - _since_: 2.8.13
*/
command(
subcommand: "GETKEYS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Extract keys and access flags given a full Redis command
* - _group_: server
* - _complexity_: O(N) where N is the number of arguments to the command
* - _since_: 7.0.0
*/
command(
subcommand: "GETKEYSANDFLAGS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Show helpful text about the different subcommands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
command(
subcommand: "HELP",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Get array of specific Redis command details, or all when no argument is given.
* - _group_: server
* - _complexity_: O(N) where N is the number of commands to look up
* - _since_: 2.8.13
*/
command(
subcommand: "INFO",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
command(
...args: [
subcommand: "INFO",
...commandNames: (string | Buffer)[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
command(
...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]
): Result<unknown[], Context>;
/**
* Get an array of Redis command names
* - _group_: server
* - _complexity_: O(N) where N is the total number of Redis commands
* - _since_: 7.0.0
*/
command(
subcommand: "LIST",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
command(
subcommand: "LIST",
filterby: "FILTERBY",
moduleNameToken: "MODULE",
moduleName: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
command(
subcommand: "LIST",
filterby: "FILTERBY",
categoryToken: "ACLCAT",
category: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
command(
subcommand: "LIST",
filterby: "FILTERBY",
patternToken: "PATTERN",
pattern: string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Get the values of configuration parameters
* - _group_: server
* - _complexity_: O(N) when N is the number of configuration parameters provided
* - _since_: 2.0.0
*/
config(
...args: [
subcommand: "GET",
...parameters: (string | Buffer)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
config(
...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
config(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Reset the stats returned by INFO
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
config(
subcommand: "RESETSTAT",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Rewrite the configuration file with the in memory configuration
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.0
*/
config(
subcommand: "REWRITE",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Set configuration parameters to the given values
* - _group_: server
* - _complexity_: O(N) when N is the number of configuration parameters provided
* - _since_: 2.0.0
*/
config(
...args: [
subcommand: "SET",
...parameterValues: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
config(
...args: [
subcommand: "SET",
...parameterValues: (string | Buffer | number)[]
]
): Result<unknown, Context>;
/**
* Copy a key
* - _group_: generic
* - _complexity_: O(N) worst case for collections, where N is the number of nested items. O(1) for string values.
* - _since_: 6.2.0
*/
copy(
source: RedisKey,
destination: RedisKey,
callback?: Callback<number>
): Result<number, Context>;
copy(
source: RedisKey,
destination: RedisKey,
replace: "REPLACE",
callback?: Callback<number>
): Result<number, Context>;
copy(
source: RedisKey,
destination: RedisKey,
destinationDbToken: "DB",
destinationDb: number | string,
callback?: Callback<number>
): Result<number, Context>;
copy(
source: RedisKey,
destination: RedisKey,
destinationDbToken: "DB",
destinationDb: number | string,
replace: "REPLACE",
callback?: Callback<number>
): Result<number, Context>;
/**
* Return the number of keys in the selected database
* - _group_: server
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
dbsize(callback?: Callback<number>): Result<number, Context>;
/**
* A container for debugging commands
* - _group_: server
* - _complexity_: Depends on subcommand.
* - _since_: 1.0.0
*/
debug(
subcommand: string,
callback?: Callback<unknown>
): Result<unknown, Context>;
debug(
...args: [
subcommand: string,
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
debug(
...args: [subcommand: string, ...args: (string | Buffer | number)[]]
): Result<unknown, Context>;
/**
* Decrement the integer value of a key by one
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
decr(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Decrement the integer value of a key by the given number
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
decrby(
key: RedisKey,
decrement: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Delete a key
* - _group_: generic
* - _complexity_: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
* - _since_: 1.0.0
*/
del(
...args: [...keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
del(
...args: [keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
del(...args: [...keys: RedisKey[]]): Result<number, Context>;
del(...args: [keys: RedisKey[]]): Result<number, Context>;
/**
* Discard all commands issued after MULTI
* - _group_: transactions
* - _complexity_: O(N), when N is the number of queued commands
* - _since_: 2.0.0
*/
discard(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Return a serialized version of the value stored at the specified key.
* - _group_: generic
* - _complexity_: O(1) to access the key and additional O(N*M) 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(1*M) where M is small, so simply O(1).
* - _since_: 2.6.0
*/
dump(key: RedisKey, callback?: Callback<string>): Result<string, Context>;
dumpBuffer(
key: RedisKey,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Echo the given string
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
echo(
message: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
echoBuffer(
message: string | Buffer,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Execute a Lua script server side
* - _group_: scripting
* - _complexity_: Depends on the script that is executed.
* - _since_: 2.6.0
*/
eval(
script: string | Buffer,
numkeys: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
...args: (string | Buffer | number)[]
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
keys: RedisKey[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
...keys: RedisKey[]
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
keys: RedisKey[]
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
eval(
...args: [
script: string | Buffer,
numkeys: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Execute a read-only Lua script server side
* - _group_: scripting
* - _complexity_: Depends on the script that is executed.
* - _since_: 7.0.0
*/
eval_ro(
...args: [
script: string | Buffer,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
eval_ro(
...args: [
script: string | Buffer,
numkeys: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Execute a Lua script server side
* - _group_: scripting
* - _complexity_: Depends on the script that is executed.
* - _since_: 2.6.0
*/
evalsha(
sha1: string | Buffer,
numkeys: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...args: (string | Buffer | number)[]
]
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
keys: RedisKey[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...keys: RedisKey[]
]
): Result<unknown, Context>;
evalsha(
...args: [sha1: string | Buffer, numkeys: number | string, keys: RedisKey[]]
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
evalsha(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Execute a read-only Lua script server side
* - _group_: scripting
* - _complexity_: Depends on the script that is executed.
* - _since_: 7.0.0
*/
evalsha_ro(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
evalsha_ro(
...args: [
sha1: string | Buffer,
numkeys: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Execute all commands issued after MULTI
* - _group_: transactions
* - _complexity_: Depends on commands in the transaction
* - _since_: 1.2.0
*/
exec(
callback?: Callback<[error: Error | null, result: unknown][] | null>
): Promise<[error: Error | null, result: unknown][] | null>;
/**
* Determine if a key exists
* - _group_: generic
* - _complexity_: O(N) where N is the number of keys to check.
* - _since_: 1.0.0
*/
exists(
...args: [...keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
exists(
...args: [keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
exists(...args: [...keys: RedisKey[]]): Result<number, Context>;
exists(...args: [keys: RedisKey[]]): Result<number, Context>;
/**
* Set a key's time to live in seconds
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
expire(
key: RedisKey,
seconds: number | string,
callback?: Callback<number>
): Result<number, Context>;
expire(
key: RedisKey,
seconds: number | string,
nx: "NX",
callback?: Callback<number>
): Result<number, Context>;
expire(
key: RedisKey,
seconds: number | string,
xx: "XX",
callback?: Callback<number>
): Result<number, Context>;
expire(
key: RedisKey,
seconds: number | string,
gt: "GT",
callback?: Callback<number>
): Result<number, Context>;
expire(
key: RedisKey,
seconds: number | string,
lt: "LT",
callback?: Callback<number>
): Result<number, Context>;
/**
* Set the expiration for a key as a UNIX timestamp
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.2.0
*/
expireat(
key: RedisKey,
unixTimeSeconds: number | string,
callback?: Callback<number>
): Result<number, Context>;
expireat(
key: RedisKey,
unixTimeSeconds: number | string,
nx: "NX",
callback?: Callback<number>
): Result<number, Context>;
expireat(
key: RedisKey,
unixTimeSeconds: number | string,
xx: "XX",
callback?: Callback<number>
): Result<number, Context>;
expireat(
key: RedisKey,
unixTimeSeconds: number | string,
gt: "GT",
callback?: Callback<number>
): Result<number, Context>;
expireat(
key: RedisKey,
unixTimeSeconds: number | string,
lt: "LT",
callback?: Callback<number>
): Result<number, Context>;
/**
* Get the expiration Unix timestamp for a key
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
expiretime(
key: RedisKey,
callback?: Callback<number>
): Result<number, Context>;
/**
* Start a coordinated failover between this server and one of its replicas.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
failover(callback?: Callback<"OK">): Result<"OK", Context>;
failover(
millisecondsToken: "TIMEOUT",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(abort: "ABORT", callback?: Callback<"OK">): Result<"OK", Context>;
failover(
abort: "ABORT",
millisecondsToken: "TIMEOUT",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
millisecondsToken: "TIMEOUT",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
abort: "ABORT",
millisecondsToken: "TIMEOUT",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
force: "FORCE",
millisecondsToken: "TIMEOUT",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
failover(
targetToken: "TO",
host: string | Buffer,
port: number | string,
force: "FORCE",
abort: "ABORT",
millisecondsToken: "TIMEOUT",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Invoke a function
* - _group_: scripting
* - _complexity_: Depends on the function that is executed.
* - _since_: 7.0.0
*/
fcall(
...args: [
function: string | Buffer,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
fcall(
...args: [
function: string | Buffer,
numkeys: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Invoke a read-only function
* - _group_: scripting
* - _complexity_: Depends on the function that is executed.
* - _since_: 7.0.0
*/
fcall_ro(
...args: [
function: string | Buffer,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
fcall_ro(
...args: [
function: string | Buffer,
numkeys: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Remove all keys from all databases
* - _group_: server
* - _complexity_: O(N) where N is the total number of keys in all databases
* - _since_: 1.0.0
*/
flushall(callback?: Callback<"OK">): Result<"OK", Context>;
flushall(async: "ASYNC", callback?: Callback<"OK">): Result<"OK", Context>;
flushall(sync: "SYNC", callback?: Callback<"OK">): Result<"OK", Context>;
/**
* 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
*/
flushdb(callback?: Callback<"OK">): Result<"OK", Context>;
flushdb(async: "ASYNC", callback?: Callback<"OK">): Result<"OK", Context>;
flushdb(sync: "SYNC", callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Delete a function by name
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
function(
subcommand: "DELETE",
libraryName: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "DELETE",
libraryName: string | Buffer,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Dump all functions into a serialized binary payload
* - _group_: scripting
* - _complexity_: O(N) where N is the number of functions
* - _since_: 7.0.0
*/
function(
subcommand: "DUMP",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "DUMP",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Deleting all functions
* - _group_: scripting
* - _complexity_: O(N) where N is the number of functions deleted
* - _since_: 7.0.0
*/
function(
subcommand: "FLUSH",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "FLUSH",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
function(
subcommand: "FLUSH",
async: "ASYNC",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "FLUSH",
async: "ASYNC",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
function(
subcommand: "FLUSH",
sync: "SYNC",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "FLUSH",
sync: "SYNC",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
function(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Kill the function currently in execution.
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
function(
subcommand: "KILL",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "KILL",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* List information about all the functions
* - _group_: scripting
* - _complexity_: O(N) where N is the number of functions
* - _since_: 7.0.0
*/
function(
subcommand: "LIST",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
function(
subcommand: "LIST",
withcode: "WITHCODE",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
function(
subcommand: "LIST",
libraryNamePatternToken: "LIBRARYNAME",
libraryNamePattern: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
function(
subcommand: "LIST",
libraryNamePatternToken: "LIBRARYNAME",
libraryNamePattern: string | Buffer,
withcode: "WITHCODE",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Create a function with the given arguments (name, code, description)
* - _group_: scripting
* - _complexity_: O(1) (considering compilation time is redundant)
* - _since_: 7.0.0
*/
function(
subcommand: "LOAD",
functionCode: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "LOAD",
functionCode: string | Buffer,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
function(
subcommand: "LOAD",
replace: "REPLACE",
functionCode: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "LOAD",
replace: "REPLACE",
functionCode: string | Buffer,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Restore all the functions on the given payload
* - _group_: scripting
* - _complexity_: O(N) where N is the number of functions on the payload
* - _since_: 7.0.0
*/
function(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
function(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
flush: "FLUSH",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
flush: "FLUSH",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
function(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
append: "APPEND",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
append: "APPEND",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
function(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
replace: "REPLACE",
callback?: Callback<string>
): Result<string, Context>;
functionBuffer(
subcommand: "RESTORE",
serializedValue: string | Buffer | number,
replace: "REPLACE",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Return information about the function currently running (name, description, duration)
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
function(
subcommand: "STATS",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Add one or more geospatial items in the geospatial index represented using a sorted set
* - _group_: geo
* - _complexity_: O(log(N)) for each item added, where N is the number of elements in the sorted set.
* - _since_: 3.2.0
*/
geoadd(
...args: [
key: RedisKey,
...longitudeLatitudeMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
...longitudeLatitudeMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
ch: "CH",
...longitudeLatitudeMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
ch: "CH",
...longitudeLatitudeMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
nx: "NX",
...longitudeLatitudeMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
nx: "NX",
...longitudeLatitudeMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
...longitudeLatitudeMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
...longitudeLatitudeMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
xx: "XX",
...longitudeLatitudeMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
xx: "XX",
...longitudeLatitudeMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
...longitudeLatitudeMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
geoadd(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
...longitudeLatitudeMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
/**
* Returns the distance between two members of a geospatial index
* - _group_: geo
* - _complexity_: O(log(N))
* - _since_: 3.2.0
*/
geodist(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
callback?: Callback<string | null>
): Result<string | null, Context>;
geodistBuffer(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
geodist(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
m: "M",
callback?: Callback<string | null>
): Result<string | null, Context>;
geodistBuffer(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
m: "M",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
geodist(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
km: "KM",
callback?: Callback<string | null>
): Result<string | null, Context>;
geodistBuffer(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
km: "KM",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
geodist(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
ft: "FT",
callback?: Callback<string | null>
): Result<string | null, Context>;
geodistBuffer(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
ft: "FT",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
geodist(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
mi: "MI",
callback?: Callback<string | null>
): Result<string | null, Context>;
geodistBuffer(
key: RedisKey,
member1: string | Buffer | number,
member2: string | Buffer | number,
mi: "MI",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Returns members of a geospatial index as standard geohash strings
* - _group_: geo
* - _complexity_: O(log(N)) for each member requested, where N is the number of elements in the sorted set.
* - _since_: 3.2.0
*/
geohash(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<string[]>
]
): Result<string[], Context>;
geohashBuffer(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
geohash(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<string[]>
]
): Result<string[], Context>;
geohashBuffer(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
geohash(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<string[], Context>;
geohashBuffer(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<Buffer[], Context>;
geohash(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<string[], Context>;
geohashBuffer(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<Buffer[], Context>;
/**
* Returns longitude and latitude of members of a geospatial index
* - _group_: geo
* - _complexity_: O(N) where N is the number of members requested.
* - _since_: 3.2.0
*/
geopos(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<([longitude: string, latitude: string] | null)[]>
]
): Result<([longitude: string, latitude: string] | null)[], Context>;
geopos(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<([longitude: string, latitude: string] | null)[]>
]
): Result<([longitude: string, latitude: string] | null)[], Context>;
geopos(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<([longitude: string, latitude: string] | null)[], Context>;
geopos(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<([longitude: string, latitude: string] | null)[], Context>;
/**
* Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point
* - _group_: geo
* - _complexity_: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
* - _since_: 3.2.0
*/
georadius(
...args: [
key: RedisKey,
longitude: number | string,
latitude: number | string,
radius: number | string,
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
georadius(
...args: [
key: RedisKey,
longitude: number | string,
latitude: number | string,
radius: number | string,
...args: RedisValue[]
]
): Result<unknown[], Context>;
/**
* A read-only variant for GEORADIUS
* - _group_: geo
* - _complexity_: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
* - _since_: 3.2.10
*/
georadius_ro(
...args: [
key: RedisKey,
longitude: number | string,
latitude: number | string,
radius: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
georadius_ro(
...args: [
key: RedisKey,
longitude: number | string,
latitude: number | string,
radius: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member
* - _group_: geo
* - _complexity_: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
* - _since_: 3.2.0
*/
georadiusbymember(
...args: [
key: RedisKey,
member: string | Buffer | number,
radius: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
georadiusbymember(
...args: [
key: RedisKey,
member: string | Buffer | number,
radius: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* A read-only variant for GEORADIUSBYMEMBER
* - _group_: geo
* - _complexity_: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
* - _since_: 3.2.10
*/
georadiusbymember_ro(
...args: [
key: RedisKey,
member: string | Buffer | number,
radius: number | string,
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
georadiusbymember_ro(
...args: [
key: RedisKey,
member: string | Buffer | number,
radius: number | string,
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
* - _group_: geo
* - _complexity_: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
* - _since_: 6.2.0
*/
geosearch(
...args: [
key: RedisKey,
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
geosearch(
...args: [key: RedisKey, ...args: RedisValue[]]
): Result<unknown[], Context>;
/**
* Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
* - _group_: geo
* - _complexity_: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
* - _since_: 6.2.0
*/
geosearchstore(
...args: [
destination: RedisKey,
source: RedisKey,
...args: RedisValue[],
callback: Callback<number>
]
): Result<number, Context>;
geosearchstore(
...args: [destination: RedisKey, source: RedisKey, ...args: RedisValue[]]
): Result<number, Context>;
/**
* Get the value of a key
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
get(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
getBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Returns the bit value at offset in the string value stored at key
* - _group_: bitmap
* - _complexity_: O(1)
* - _since_: 2.2.0
*/
getbit(
key: RedisKey,
offset: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Get the value of a key and delete the key
* - _group_: string
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
getdel(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
getdelBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Get the value of a key and optionally set its expiration
* - _group_: string
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
getex(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
getexBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
getex(
key: RedisKey,
secondsToken: "EX",
seconds: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
getexBuffer(
key: RedisKey,
secondsToken: "EX",
seconds: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
getex(
key: RedisKey,
millisecondsToken: "PX",
milliseconds: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
getexBuffer(
key: RedisKey,
millisecondsToken: "PX",
milliseconds: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
getex(
key: RedisKey,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
getexBuffer(
key: RedisKey,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
getex(
key: RedisKey,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
getexBuffer(
key: RedisKey,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
getex(
key: RedisKey,
persist: "PERSIST",
callback?: Callback<string | null>
): Result<string | null, Context>;
getexBuffer(
key: RedisKey,
persist: "PERSIST",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Get a substring of the string stored at a key
* - _group_: string
* - _complexity_: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
* - _since_: 2.4.0
*/
getrange(
key: RedisKey,
start: number | string,
end: number | string,
callback?: Callback<string>
): Result<string, Context>;
getrangeBuffer(
key: RedisKey,
start: number | string,
end: number | string,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Set the string value of a key and return its old value
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
getset(
key: RedisKey,
value: string | Buffer | number,
callback?: Callback<string | null>
): Result<string | null, Context>;
getsetBuffer(
key: RedisKey,
value: string | Buffer | number,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Delete one or more hash fields
* - _group_: hash
* - _complexity_: O(N) where N is the number of fields to be removed.
* - _since_: 2.0.0
*/
hdel(
...args: [
key: RedisKey,
...fields: (string | Buffer)[],
callback: Callback<number>
]
): Result<number, Context>;
hdel(
...args: [key: RedisKey, ...fields: (string | Buffer)[]]
): Result<number, Context>;
/**
* Handshake with Redis
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 6.0.0
*/
hello(callback?: Callback<unknown[]>): Result<unknown[], Context>;
hello(
protover: number | string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
hello(
protover: number | string,
clientnameToken: "SETNAME",
clientname: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
hello(
protover: number | string,
usernamePasswordToken: "AUTH",
username: string | Buffer,
password: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
hello(
protover: number | string,
usernamePasswordToken: "AUTH",
username: string | Buffer,
password: string | Buffer,
clientnameToken: "SETNAME",
clientname: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Determine if a hash field exists
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
hexists(
key: RedisKey,
field: string | Buffer,
callback?: Callback<number>
): Result<number, Context>;
/**
* Get the value of a hash field
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
hget(
key: RedisKey,
field: string | Buffer,
callback?: Callback<string | null>
): Result<string | null, Context>;
hgetBuffer(
key: RedisKey,
field: string | Buffer,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Get all the fields and values in a hash
* - _group_: hash
* - _complexity_: O(N) where N is the size of the hash.
* - _since_: 2.0.0
*/
hgetall(
key: RedisKey,
callback?: Callback<Record<string, string>>
): Result<Record<string, string>, Context>;
hgetallBuffer(
key: RedisKey,
callback?: Callback<Record<string, Buffer>>
): Result<Record<string, Buffer>, Context>;
/**
* Increment the integer value of a hash field by the given number
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
hincrby(
key: RedisKey,
field: string | Buffer,
increment: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Increment the float value of a hash field by the given amount
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
hincrbyfloat(
key: RedisKey,
field: string | Buffer,
increment: number | string,
callback?: Callback<string>
): Result<string, Context>;
hincrbyfloatBuffer(
key: RedisKey,
field: string | Buffer,
increment: number | string,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Get all the fields in a hash
* - _group_: hash
* - _complexity_: O(N) where N is the size of the hash.
* - _since_: 2.0.0
*/
hkeys(
key: RedisKey,
callback?: Callback<string[]>
): Result<string[], Context>;
hkeysBuffer(
key: RedisKey,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Get the number of fields in a hash
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
hlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Get the values of all the given hash fields
* - _group_: hash
* - _complexity_: O(N) where N is the number of fields being requested.
* - _since_: 2.0.0
*/
hmget(
...args: [
key: RedisKey,
...fields: (string | Buffer)[],
callback: Callback<(string | null)[]>
]
): Result<(string | null)[], Context>;
hmgetBuffer(
...args: [
key: RedisKey,
...fields: (string | Buffer)[],
callback: Callback<(Buffer | null)[]>
]
): Result<(Buffer | null)[], Context>;
hmget(
...args: [key: RedisKey, ...fields: (string | Buffer)[]]
): Result<(string | null)[], Context>;
hmgetBuffer(
...args: [key: RedisKey, ...fields: (string | Buffer)[]]
): Result<(Buffer | null)[], Context>;
/**
* Set multiple hash fields to multiple values
* - _group_: hash
* - _complexity_: O(N) where N is the number of fields being set.
* - _since_: 2.0.0
*/
hmset(
key: RedisKey,
object: object,
callback?: Callback<"OK">
): Result<"OK", Context>;
hmset(
key: RedisKey,
map: Map<string | Buffer | number, string | Buffer | number>,
callback?: Callback<"OK">
): Result<"OK", Context>;
hmset(
...args: [
key: RedisKey,
...fieldValues: (string | Buffer | number)[],
callback: Callback<"OK">
]
): Result<"OK", Context>;
hmset(
...args: [key: RedisKey, ...fieldValues: (string | Buffer | number)[]]
): Result<"OK", Context>;
/**
* Get one or multiple random fields from a hash
* - _group_: hash
* - _complexity_: O(N) where N is the number of fields returned
* - _since_: 6.2.0
*/
hrandfield(
key: RedisKey,
callback?: Callback<string | unknown[] | null>
): Result<string | unknown[] | null, Context>;
hrandfieldBuffer(
key: RedisKey,
callback?: Callback<Buffer | unknown[] | null>
): Result<Buffer | unknown[] | null, Context>;
hrandfield(
key: RedisKey,
count: number | string,
callback?: Callback<string | unknown[] | null>
): Result<string | unknown[] | null, Context>;
hrandfieldBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer | unknown[] | null>
): Result<Buffer | unknown[] | null, Context>;
hrandfield(
key: RedisKey,
count: number | string,
withvalues: "WITHVALUES",
callback?: Callback<string | unknown[] | null>
): Result<string | unknown[] | null, Context>;
hrandfieldBuffer(
key: RedisKey,
count: number | string,
withvalues: "WITHVALUES",
callback?: Callback<Buffer | unknown[] | null>
): Result<Buffer | unknown[] | null, Context>;
/**
* Incrementally iterate hash fields and associated values
* - _group_: hash
* - _complexity_: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
* - _since_: 2.8.0
*/
hscan(
key: RedisKey,
cursor: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
hscanBuffer(
key: RedisKey,
cursor: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
hscan(
key: RedisKey,
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
hscanBuffer(
key: RedisKey,
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
hscan(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
hscanBuffer(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
hscan(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
hscanBuffer(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
/**
* Set the string value of a hash field
* - _group_: hash
* - _complexity_: O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.
* - _since_: 2.0.0
*/
hset(
key: RedisKey,
object: object,
callback?: Callback<number>
): Result<number, Context>;
hset(
key: RedisKey,
map: Map<string | Buffer | number, string | Buffer | number>,
callback?: Callback<number>
): Result<number, Context>;
hset(
...args: [
key: RedisKey,
...fieldValues: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
hset(
...args: [key: RedisKey, ...fieldValues: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Set the value of a hash field, only if the field does not exist
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
hsetnx(
key: RedisKey,
field: string | Buffer,
value: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Get the length of the value of a hash field
* - _group_: hash
* - _complexity_: O(1)
* - _since_: 3.2.0
*/
hstrlen(
key: RedisKey,
field: string | Buffer,
callback?: Callback<number>
): Result<number, Context>;
/**
* Get all the values in a hash
* - _group_: hash
* - _complexity_: O(N) where N is the size of the hash.
* - _since_: 2.0.0
*/
hvals(
key: RedisKey,
callback?: Callback<string[]>
): Result<string[], Context>;
hvalsBuffer(
key: RedisKey,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Increment the integer value of a key by one
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
incr(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Increment the integer value of a key by the given amount
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
incrby(
key: RedisKey,
increment: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Increment the float value of a key by the given amount
* - _group_: string
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
incrbyfloat(
key: RedisKey,
increment: number | string,
callback?: Callback<string>
): Result<string, Context>;
/**
* Get information and statistics about the server
* - _group_: server
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
info(callback?: Callback<string>): Result<string, Context>;
info(
...args: [...sections: (string | Buffer)[], callback: Callback<string>]
): Result<string, Context>;
info(...args: [...sections: (string | Buffer)[]]): Result<string, Context>;
/**
* Find all keys matching the given pattern
* - _group_: generic
* - _complexity_: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
* - _since_: 1.0.0
*/
keys(
pattern: string,
callback?: Callback<string[]>
): Result<string[], Context>;
keysBuffer(
pattern: string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Get the UNIX time stamp of the last successful save to disk
* - _group_: server
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
lastsave(callback?: Callback<number>): Result<number, Context>;
/**
* Return a human readable latency analysis report.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
latency(
subcommand: "DOCTOR",
callback?: Callback<string>
): Result<string, Context>;
/**
* Return a latency graph for the event.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
latency(
subcommand: "GRAPH",
event: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
/**
* Show helpful text about the different subcommands.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
latency(
subcommand: "HELP",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Return the cumulative distribution of latencies of a subset of commands or all.
* - _group_: server
* - _complexity_: O(N) where N is the number of commands with latency information being retrieved.
* - _since_: 7.0.0
*/
latency(
subcommand: "HISTOGRAM",
callback?: Callback<unknown>
): Result<unknown, Context>;
latency(
...args: [
subcommand: "HISTOGRAM",
...commands: (string | Buffer)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
latency(
...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* Return timestamp-latency samples for the event.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
latency(
subcommand: "HISTORY",
event: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Return the latest latency samples for all events.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
latency(
subcommand: "LATEST",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Reset latency data for one or more events.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.13
*/
latency(
subcommand: "RESET",
callback?: Callback<number>
): Result<number, Context>;
latency(
...args: [
subcommand: "RESET",
...events: (string | Buffer)[],
callback: Callback<number>
]
): Result<number, Context>;
latency(
...args: [subcommand: "RESET", ...events: (string | Buffer)[]]
): Result<number, Context>;
/**
* Find 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
*/
lcs(
key1: RedisKey,
key2: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
lenToken: "MINMATCHLEN",
len: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
lenToken: "MINMATCHLEN",
len: number | string,
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
idx: "IDX",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
idx: "IDX",
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
idx: "IDX",
lenToken: "MINMATCHLEN",
len: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
idx: "IDX",
lenToken: "MINMATCHLEN",
len: number | string,
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
lenToken: "MINMATCHLEN",
len1: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
lenToken: "MINMATCHLEN",
len1: number | string,
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
idx: "IDX",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
idx: "IDX",
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
idx: "IDX",
lenToken: "MINMATCHLEN",
len1: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
lcs(
key1: RedisKey,
key2: RedisKey,
len: "LEN",
idx: "IDX",
lenToken: "MINMATCHLEN",
len1: number | string,
withmatchlen: "WITHMATCHLEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get an element from a list by its index
* - _group_: list
* - _complexity_: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
* - _since_: 1.0.0
*/
lindex(
key: RedisKey,
index: number | string,
callback?: Callback<string | null>
): Result<string | null, Context>;
lindexBuffer(
key: RedisKey,
index: number | string,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Insert an element before or after another element in a list
* - _group_: list
* - _complexity_: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
* - _since_: 2.2.0
*/
linsert(
key: RedisKey,
before: "BEFORE",
pivot: string | Buffer | number,
element: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
linsert(
key: RedisKey,
after: "AFTER",
pivot: string | Buffer | number,
element: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Get the length of a list
* - _group_: list
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
llen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Pop an element from a list, push it to another list and return it
* - _group_: list
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
lmove(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
left1: "LEFT",
callback?: Callback<string>
): Result<string, Context>;
lmoveBuffer(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
left1: "LEFT",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
lmove(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
right: "RIGHT",
callback?: Callback<string>
): Result<string, Context>;
lmoveBuffer(
source: RedisKey,
destination: RedisKey,
left: "LEFT",
right: "RIGHT",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
lmove(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
left: "LEFT",
callback?: Callback<string>
): Result<string, Context>;
lmoveBuffer(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
left: "LEFT",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
lmove(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
right1: "RIGHT",
callback?: Callback<string>
): Result<string, Context>;
lmoveBuffer(
source: RedisKey,
destination: RedisKey,
right: "RIGHT",
right1: "RIGHT",
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Pop elements from a list
* - _group_: list
* - _complexity_: O(N+M) where N is the number of provided keys and M is the number of elements returned.
* - _since_: 7.0.0
*/
lmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [numkeys: number | string, ...keys: RedisKey[], left: "LEFT"]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [numkeys: number | string, ...keys: RedisKey[], left: "LEFT"]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [numkeys: number | string, keys: RedisKey[], left: "LEFT"]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [numkeys: number | string, keys: RedisKey[], left: "LEFT"]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
left: "LEFT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [numkeys: number | string, ...keys: RedisKey[], right: "RIGHT"]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [numkeys: number | string, ...keys: RedisKey[], right: "RIGHT"]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [numkeys: number | string, keys: RedisKey[], right: "RIGHT"]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [numkeys: number | string, keys: RedisKey[], right: "RIGHT"]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: string, members: string[]] | null>
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string,
callback: Callback<[key: Buffer, members: Buffer[]] | null>
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
lmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: string, members: string[]] | null, Context>;
lmpopBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
right: "RIGHT",
countToken: "COUNT",
count: number | string
]
): Result<[key: Buffer, members: Buffer[]] | null, Context>;
/**
* Display some computer art and the Redis version
* - _group_: server
* - _complexity_: undefined
* - _since_: 5.0.0
*/
lolwut(callback?: Callback<string>): Result<string, Context>;
lolwut(
versionToken: "VERSION",
version: number | string,
callback?: Callback<string>
): Result<string, Context>;
/**
* Remove and get the first elements in a list
* - _group_: list
* - _complexity_: O(N) where N is the number of elements returned
* - _since_: 1.0.0
*/
lpop(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
lpopBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
lpop(
key: RedisKey,
count: number | string,
callback?: Callback<string[] | null>
): Result<string[] | null, Context>;
lpopBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[] | null>
): Result<Buffer[] | null, Context>;
/**
* Return the index of matching elements on a list
* - _group_: list
* - _complexity_: O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.
* - _since_: 6.0.6
*/
lpos(
key: RedisKey,
element: string | Buffer | number,
callback?: Callback<number | null>
): Result<number | null, Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
lenToken: "MAXLEN",
len: number | string,
callback?: Callback<number | null>
): Result<number | null, Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
numMatchesToken: "COUNT",
numMatches: number | string,
callback?: Callback<number[]>
): Result<number[], Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
numMatchesToken: "COUNT",
numMatches: number | string,
lenToken: "MAXLEN",
len: number | string,
callback?: Callback<number[]>
): Result<number[], Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
rankToken: "RANK",
rank: number | string,
callback?: Callback<number | null>
): Result<number | null, Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
rankToken: "RANK",
rank: number | string,
lenToken: "MAXLEN",
len: number | string,
callback?: Callback<number | null>
): Result<number | null, Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
rankToken: "RANK",
rank: number | string,
numMatchesToken: "COUNT",
numMatches: number | string,
callback?: Callback<number[]>
): Result<number[], Context>;
lpos(
key: RedisKey,
element: string | Buffer | number,
rankToken: "RANK",
rank: number | string,
numMatchesToken: "COUNT",
numMatches: number | string,
lenToken: "MAXLEN",
len: number | string,
callback?: Callback<number[]>
): Result<number[], Context>;
/**
* Prepend one or multiple elements to a list
* - _group_: list
* - _complexity_: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
* - _since_: 1.0.0
*/
lpush(
...args: [
key: RedisKey,
...elements: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
lpush(
...args: [key: RedisKey, ...elements: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Prepend an element to a list, only if the list exists
* - _group_: list
* - _complexity_: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
* - _since_: 2.2.0
*/
lpushx(
...args: [
key: RedisKey,
...elements: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
lpushx(
...args: [key: RedisKey, ...elements: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Get a range of elements from a list
* - _group_: list
* - _complexity_: O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
* - _since_: 1.0.0
*/
lrange(
key: RedisKey,
start: number | string,
stop: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
lrangeBuffer(
key: RedisKey,
start: number | string,
stop: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Remove elements from a list
* - _group_: list
* - _complexity_: O(N+M) where N is the length of the list and M is the number of elements removed.
* - _since_: 1.0.0
*/
lrem(
key: RedisKey,
count: number | string,
element: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Set the value of an element in a list by its index
* - _group_: list
* - _complexity_: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
* - _since_: 1.0.0
*/
lset(
key: RedisKey,
index: number | string,
element: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Trim a list to the specified range
* - _group_: list
* - _complexity_: O(N) where N is the number of elements to be removed by the operation.
* - _since_: 1.0.0
*/
ltrim(
key: RedisKey,
start: number | string,
stop: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Outputs memory problems report
* - _group_: server
* - _complexity_: O(1)
* - _since_: 4.0.0
*/
memory(
subcommand: "DOCTOR",
callback?: Callback<string>
): Result<string, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 4.0.0
*/
memory(
subcommand: "HELP",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Show allocator internal stats
* - _group_: server
* - _complexity_: Depends on how much memory is allocated, could be slow
* - _since_: 4.0.0
*/
memory(
subcommand: "MALLOC-STATS",
callback?: Callback<string>
): Result<string, Context>;
/**
* Ask the allocator to release memory
* - _group_: server
* - _complexity_: Depends on how much memory is allocated, could be slow
* - _since_: 4.0.0
*/
memory(subcommand: "PURGE", callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Show memory usage details
* - _group_: server
* - _complexity_: O(1)
* - _since_: 4.0.0
*/
memory(
subcommand: "STATS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Estimate the memory usage of a key
* - _group_: server
* - _complexity_: O(N) where N is the number of samples.
* - _since_: 4.0.0
*/
memory(
subcommand: "USAGE",
key: RedisKey,
callback?: Callback<number | null>
): Result<number | null, Context>;
memory(
subcommand: "USAGE",
key: RedisKey,
countToken: "SAMPLES",
count: number | string,
callback?: Callback<number | null>
): Result<number | null, Context>;
/**
* Get the values of all the given keys
* - _group_: string
* - _complexity_: O(N) where N is the number of keys to retrieve.
* - _since_: 1.0.0
*/
mget(
...args: [...keys: RedisKey[], callback: Callback<(string | null)[]>]
): Result<(string | null)[], Context>;
mgetBuffer(
...args: [...keys: RedisKey[], callback: Callback<(Buffer | null)[]>]
): Result<(Buffer | null)[], Context>;
mget(
...args: [keys: RedisKey[], callback: Callback<(string | null)[]>]
): Result<(string | null)[], Context>;
mgetBuffer(
...args: [keys: RedisKey[], callback: Callback<(Buffer | null)[]>]
): Result<(Buffer | null)[], Context>;
mget(...args: [...keys: RedisKey[]]): Result<(string | null)[], Context>;
mgetBuffer(
...args: [...keys: RedisKey[]]
): Result<(Buffer | null)[], Context>;
mget(...args: [keys: RedisKey[]]): Result<(string | null)[], Context>;
mgetBuffer(...args: [keys: RedisKey[]]): Result<(Buffer | null)[], Context>;
/**
* Atomically transfer a key from a Redis instance to another one.
* - _group_: generic
* - _complexity_: This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
* - _since_: 2.6.0
*/
migrate(
...args: [
host: string | Buffer,
port: number | string,
...args: RedisValue[],
callback: Callback<"OK">
]
): Result<"OK", Context>;
migrate(
...args: [
host: string | Buffer,
port: number | string,
...args: RedisValue[]
]
): Result<"OK", Context>;
/**
* Show helpful text about the different subcommands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
module(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* List all modules loaded by the server
* - _group_: server
* - _complexity_: O(N) where N is the number of loaded modules.
* - _since_: 4.0.0
*/
module(
subcommand: "LIST",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Load a module
* - _group_: server
* - _complexity_: O(1)
* - _since_: 4.0.0
*/
module(
subcommand: "LOAD",
path: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOAD",
path: string | Buffer,
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOAD",
path: string | Buffer,
...args: (string | Buffer | number)[]
]
): Result<unknown, Context>;
/**
* Load a module with extended parameters
* - _group_: server
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
module(
subcommand: "LOADEX",
path: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOADEX",
path: string | Buffer,
argsToken: "ARGS",
...args: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOADEX",
path: string | Buffer,
argsToken: "ARGS",
...args: (string | Buffer | number)[]
]
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOADEX",
path: string | Buffer,
configsToken: "CONFIG",
...configs: (string | Buffer | number)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOADEX",
path: string | Buffer,
configsToken: "CONFIG",
...configs: (string | Buffer | number)[]
]
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOADEX",
path: string | Buffer,
configsToken: "CONFIG",
...args: RedisValue[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
module(
...args: [
subcommand: "LOADEX",
path: string | Buffer,
configsToken: "CONFIG",
...args: RedisValue[]
]
): Result<unknown, Context>;
/**
* Unload a module
* - _group_: server
* - _complexity_: O(1)
* - _since_: 4.0.0
*/
module(
subcommand: "UNLOAD",
name: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Move a key to another database
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
move(
key: RedisKey,
db: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Set multiple keys to multiple values
* - _group_: string
* - _complexity_: O(N) where N is the number of keys to set.
* - _since_: 1.0.1
*/
mset(object: object, callback?: Callback<"OK">): Result<"OK", Context>;
mset(
map: Map<string | Buffer | number, string | Buffer | number>,
callback?: Callback<"OK">
): Result<"OK", Context>;
mset(
...args: [
...keyValues: (RedisKey | string | Buffer | number)[],
callback: Callback<"OK">
]
): Result<"OK", Context>;
mset(
...args: [...keyValues: (RedisKey | string | Buffer | number)[]]
): Result<"OK", Context>;
/**
* Set multiple keys to multiple values, only if none of the keys exist
* - _group_: string
* - _complexity_: O(N) where N is the number of keys to set.
* - _since_: 1.0.1
*/
msetnx(object: object, callback?: Callback<"OK">): Result<"OK", Context>;
msetnx(
map: Map<string | Buffer | number, string | Buffer | number>,
callback?: Callback<"OK">
): Result<"OK", Context>;
msetnx(
...args: [
...keyValues: (RedisKey | string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
msetnx(
...args: [...keyValues: (RedisKey | string | Buffer | number)[]]
): Result<number, Context>;
/**
* Inspect the internal encoding of a Redis object
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.2.3
*/
object(
subcommand: "ENCODING",
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get the logarithmic access frequency counter of a Redis object
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 4.0.0
*/
object(
subcommand: "FREQ",
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
object(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get the time since a Redis object was last accessed
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.2.3
*/
object(
subcommand: "IDLETIME",
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get the number of references to the value of the key
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.2.3
*/
object(
subcommand: "REFCOUNT",
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Remove the expiration from a key
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.2.0
*/
persist(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Set a key's time to live in milliseconds
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
pexpire(
key: RedisKey,
milliseconds: number | string,
callback?: Callback<number>
): Result<number, Context>;
pexpire(
key: RedisKey,
milliseconds: number | string,
nx: "NX",
callback?: Callback<number>
): Result<number, Context>;
pexpire(
key: RedisKey,
milliseconds: number | string,
xx: "XX",
callback?: Callback<number>
): Result<number, Context>;
pexpire(
key: RedisKey,
milliseconds: number | string,
gt: "GT",
callback?: Callback<number>
): Result<number, Context>;
pexpire(
key: RedisKey,
milliseconds: number | string,
lt: "LT",
callback?: Callback<number>
): Result<number, Context>;
/**
* Set the expiration for a key as a UNIX timestamp specified in milliseconds
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
pexpireat(
key: RedisKey,
unixTimeMilliseconds: number | string,
callback?: Callback<number>
): Result<number, Context>;
pexpireat(
key: RedisKey,
unixTimeMilliseconds: number | string,
nx: "NX",
callback?: Callback<number>
): Result<number, Context>;
pexpireat(
key: RedisKey,
unixTimeMilliseconds: number | string,
xx: "XX",
callback?: Callback<number>
): Result<number, Context>;
pexpireat(
key: RedisKey,
unixTimeMilliseconds: number | string,
gt: "GT",
callback?: Callback<number>
): Result<number, Context>;
pexpireat(
key: RedisKey,
unixTimeMilliseconds: number | string,
lt: "LT",
callback?: Callback<number>
): Result<number, Context>;
/**
* Get the expiration Unix timestamp for a key in milliseconds
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 7.0.0
*/
pexpiretime(
key: RedisKey,
callback?: Callback<number>
): Result<number, Context>;
/**
* Adds the specified elements to the specified HyperLogLog.
* - _group_: hyperloglog
* - _complexity_: O(1) to add every element.
* - _since_: 2.8.9
*/
pfadd(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
pfadd(
...args: [
key: RedisKey,
...elements: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
pfadd(
...args: [key: RedisKey, ...elements: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
* - _group_: hyperloglog
* - _complexity_: O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.
* - _since_: 2.8.9
*/
pfcount(
...args: [...keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
pfcount(
...args: [keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
pfcount(...args: [...keys: RedisKey[]]): Result<number, Context>;
pfcount(...args: [keys: RedisKey[]]): Result<number, Context>;
/**
* Internal commands for debugging HyperLogLog values
* - _group_: hyperloglog
* - _complexity_: N/A
* - _since_: 2.8.9
*/
pfdebug(
subcommand: string | Buffer,
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Merge N different HyperLogLogs into a single one.
* - _group_: hyperloglog
* - _complexity_: O(N) to merge N HyperLogLogs, but with high constant times.
* - _since_: 2.8.9
*/
pfmerge(
...args: [
destkey: RedisKey,
...sourcekeys: RedisKey[],
callback: Callback<"OK">
]
): Result<"OK", Context>;
pfmerge(
...args: [
destkey: RedisKey,
sourcekeys: RedisKey[],
callback: Callback<"OK">
]
): Result<"OK", Context>;
pfmerge(
...args: [destkey: RedisKey, ...sourcekeys: RedisKey[]]
): Result<"OK", Context>;
pfmerge(
...args: [destkey: RedisKey, sourcekeys: RedisKey[]]
): Result<"OK", Context>;
/**
* An internal command for testing HyperLogLog values
* - _group_: hyperloglog
* - _complexity_: N/A
* - _since_: 2.8.9
*/
pfselftest(callback?: Callback<unknown>): Result<unknown, Context>;
/**
* Ping the server
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
ping(callback?: Callback<"PONG">): Result<"PONG", Context>;
ping(
message: string | Buffer,
callback?: Callback<string>
): Result<string, Context>;
pingBuffer(
message: string | Buffer,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Set the value and expiration in milliseconds of a key
* - _group_: string
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
psetex(
key: RedisKey,
milliseconds: number | string,
value: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Listen for messages published to channels matching the given patterns
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of patterns the client is already subscribed to.
* - _since_: 2.0.0
*/
psubscribe(
...args: [...patterns: string[], callback: Callback<unknown>]
): Result<unknown, Context>;
psubscribe(...args: [...patterns: string[]]): Result<unknown, Context>;
/**
* Internal command used for replication
* - _group_: server
* - _complexity_: undefined
* - _since_: 2.8.0
*/
psync(
replicationid: string | Buffer | number,
offset: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get the time to live for a key in milliseconds
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
pttl(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Post a message to a channel
* - _group_: pubsub
* - _complexity_: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).
* - _since_: 2.0.0
*/
publish(
channel: string | Buffer,
message: string | Buffer,
callback?: Callback<number>
): Result<number, Context>;
/**
* List active channels
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)
* - _since_: 2.8.0
*/
pubsub(
subcommand: "CHANNELS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
pubsub(
subcommand: "CHANNELS",
pattern: string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Show helpful text about the different subcommands
* - _group_: pubsub
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
pubsub(
subcommand: "HELP",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Get the count of unique patterns pattern subscriptions
* - _group_: pubsub
* - _complexity_: O(1)
* - _since_: 2.8.0
*/
pubsub(
subcommand: "NUMPAT",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Get the count of subscribers for channels
* - _group_: pubsub
* - _complexity_: O(N) for the NUMSUB subcommand, where N is the number of requested channels
* - _since_: 2.8.0
*/
pubsub(
subcommand: "NUMSUB",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
pubsub(
...args: [
subcommand: "NUMSUB",
...channels: (string | Buffer)[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
pubsub(
...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]
): Result<unknown[], Context>;
/**
* List active shard channels
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).
* - _since_: 7.0.0
*/
pubsub(
subcommand: "SHARDCHANNELS",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
pubsub(
subcommand: "SHARDCHANNELS",
pattern: string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Get the count of subscribers for shard channels
* - _group_: pubsub
* - _complexity_: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels
* - _since_: 7.0.0
*/
pubsub(
subcommand: "SHARDNUMSUB",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
pubsub(
...args: [
subcommand: "SHARDNUMSUB",
...shardchannels: (string | Buffer)[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
pubsub(
...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]
): Result<unknown[], Context>;
/**
* Stop listening for messages posted to channels matching the given patterns
* - _group_: pubsub
* - _complexity_: O(N+M) where N is the number of patterns the client is already subscribed and M is the number of total patterns subscribed in the system (by any client).
* - _since_: 2.0.0
*/
punsubscribe(callback?: Callback<unknown>): Result<unknown, Context>;
punsubscribe(
...args: [...patterns: string[], callback: Callback<unknown>]
): Result<unknown, Context>;
punsubscribe(...args: [...patterns: string[]]): Result<unknown, Context>;
/**
* Close the connection
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
quit(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Return a random key from the keyspace
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
randomkey(callback?: Callback<string | null>): Result<string | null, Context>;
randomkeyBuffer(
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Enables read queries for a connection to a cluster replica node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
readonly(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Disables read queries for a connection to a cluster replica node
* - _group_: cluster
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
readwrite(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Rename a key
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
rename(
key: RedisKey,
newkey: RedisKey,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Rename a key, only if the new key does not exist
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
renamenx(
key: RedisKey,
newkey: RedisKey,
callback?: Callback<number>
): Result<number, Context>;
/**
* An internal command for configuring the replication stream
* - _group_: server
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
replconf(callback?: Callback<unknown>): Result<unknown, Context>;
/**
* Make the server a replica of another instance, or promote it as master.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
replicaof(
host: string | Buffer,
port: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Reset the connection
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
reset(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Create a key using the provided serialized value, previously obtained using DUMP.
* - _group_: generic
* - _complexity_: O(1) to create the new key and additional O(N*M) 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(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).
* - _since_: 2.6.0
*/
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
restore(
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* An internal command for migrating keys in a cluster
* - _group_: server
* - _complexity_: O(1) to create the new key and additional O(N*M) 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(1*M) where M is small, so simply O(1). However for sorted set values the complexity is O(N*M*log(N)) because inserting values into sorted sets is O(log(N)).
* - _since_: 3.0.0
*/
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
["restore-asking"](
key: RedisKey,
ttl: number | string,
serializedValue: string | Buffer | number,
replace: "REPLACE",
absttl: "ABSTTL",
secondsToken: "IDLETIME",
seconds: number | string,
frequencyToken: "FREQ",
frequency: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Return the role of the instance in the context of replication
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.8.12
*/
role(callback?: Callback<unknown[]>): Result<unknown[], Context>;
/**
* Remove and get the last elements in a list
* - _group_: list
* - _complexity_: O(N) where N is the number of elements returned
* - _since_: 1.0.0
*/
rpop(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
rpopBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
rpop(
key: RedisKey,
count: number | string,
callback?: Callback<string[] | null>
): Result<string[] | null, Context>;
rpopBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[] | null>
): Result<Buffer[] | null, Context>;
/**
* Remove the last element in a list, prepend it to another list and return it
* - _group_: list
* - _complexity_: O(1)
* - _since_: 1.2.0
*/
rpoplpush(
source: RedisKey,
destination: RedisKey,
callback?: Callback<string>
): Result<string, Context>;
rpoplpushBuffer(
source: RedisKey,
destination: RedisKey,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Append one or multiple elements to a list
* - _group_: list
* - _complexity_: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
* - _since_: 1.0.0
*/
rpush(
...args: [
key: RedisKey,
...elements: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
rpush(
...args: [key: RedisKey, ...elements: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Append an element to a list, only if the list exists
* - _group_: list
* - _complexity_: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
* - _since_: 2.2.0
*/
rpushx(
...args: [
key: RedisKey,
...elements: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
rpushx(
...args: [key: RedisKey, ...elements: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Add one or more members to a set
* - _group_: set
* - _complexity_: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
* - _since_: 1.0.0
*/
sadd(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
sadd(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
sadd(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<number, Context>;
sadd(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Synchronously save the dataset to disk
* - _group_: server
* - _complexity_: O(N) where N is the total number of keys in all databases
* - _since_: 1.0.0
*/
save(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Incrementally iterate the keys space
* - _group_: generic
* - _complexity_: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
* - _since_: 2.8.0
*/
scan(
cursor: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
countToken: "COUNT",
count: number | string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
countToken: "COUNT",
count: number | string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
scan(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
scanBuffer(
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
typeToken: "TYPE",
type: string | Buffer,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
/**
* Get the number of members in a set
* - _group_: set
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
scard(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Set the debug mode for executed scripts.
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 3.2.0
*/
script(
subcommand: "DEBUG",
yes: "YES",
callback?: Callback<unknown>
): Result<unknown, Context>;
script(
subcommand: "DEBUG",
sync: "SYNC",
callback?: Callback<unknown>
): Result<unknown, Context>;
script(
subcommand: "DEBUG",
no: "NO",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Check existence of scripts in the script cache.
* - _group_: scripting
* - _complexity_: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
* - _since_: 2.6.0
*/
script(
...args: [
subcommand: "EXISTS",
...sha1s: (string | Buffer)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
script(
...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* Remove all the scripts from the script cache.
* - _group_: scripting
* - _complexity_: O(N) with N being the number of scripts in cache
* - _since_: 2.6.0
*/
script(
subcommand: "FLUSH",
callback?: Callback<unknown>
): Result<unknown, Context>;
script(
subcommand: "FLUSH",
async: "ASYNC",
callback?: Callback<unknown>
): Result<unknown, Context>;
script(
subcommand: "FLUSH",
sync: "SYNC",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
script(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Kill the script currently in execution.
* - _group_: scripting
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
script(
subcommand: "KILL",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Load the specified Lua script into the script cache.
* - _group_: scripting
* - _complexity_: O(N) with N being the length in bytes of the script body.
* - _since_: 2.6.0
*/
script(
subcommand: "LOAD",
script: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Subtract multiple sets
* - _group_: set
* - _complexity_: O(N) where N is the total number of elements in all given sets.
* - _since_: 1.0.0
*/
sdiff(
...args: [...keys: RedisKey[], callback: Callback<string[]>]
): Result<string[], Context>;
sdiffBuffer(
...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]
): Result<Buffer[], Context>;
sdiff(
...args: [keys: RedisKey[], callback: Callback<string[]>]
): Result<string[], Context>;
sdiffBuffer(
...args: [keys: RedisKey[], callback: Callback<Buffer[]>]
): Result<Buffer[], Context>;
sdiff(...args: [...keys: RedisKey[]]): Result<string[], Context>;
sdiffBuffer(...args: [...keys: RedisKey[]]): Result<Buffer[], Context>;
sdiff(...args: [keys: RedisKey[]]): Result<string[], Context>;
sdiffBuffer(...args: [keys: RedisKey[]]): Result<Buffer[], Context>;
/**
* Subtract multiple sets and store the resulting set in a key
* - _group_: set
* - _complexity_: O(N) where N is the total number of elements in all given sets.
* - _since_: 1.0.0
*/
sdiffstore(
...args: [
destination: RedisKey,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sdiffstore(
...args: [
destination: RedisKey,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sdiffstore(
...args: [destination: RedisKey, ...keys: RedisKey[]]
): Result<number, Context>;
sdiffstore(
...args: [destination: RedisKey, keys: RedisKey[]]
): Result<number, Context>;
/**
* Change the selected database for the current connection
* - _group_: connection
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
select(
index: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Set the string value of a key
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
set(
key: RedisKey,
value: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
set(
key: RedisKey,
value: string | Buffer | number,
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
nx: "NX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
nx: "NX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
nx: "NX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
xx: "XX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
xx: "XX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
xx: "XX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
set(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
nx: "NX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
xx: "XX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
secondsToken: "EX",
seconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
set(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
nx: "NX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
xx: "XX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
millisecondsToken: "PX",
milliseconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
nx: "NX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
xx: "XX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
unixTimeSecondsToken: "EXAT",
unixTimeSeconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
nx: "NX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
nx: "NX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
xx: "XX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
unixTimeMillisecondsToken: "PXAT",
unixTimeMilliseconds: number | string,
xx: "XX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
callback?: Callback<"OK">
): Result<"OK", Context>;
set(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
nx: "NX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
nx: "NX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
nx: "NX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
xx: "XX",
callback?: Callback<"OK" | null>
): Result<"OK" | null, Context>;
set(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
xx: "XX",
get: "GET",
callback?: Callback<string | null>
): Result<string | null, Context>;
setBuffer(
key: RedisKey,
value: string | Buffer | number,
keepttl: "KEEPTTL",
xx: "XX",
get: "GET",
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Sets or clears the bit at offset in the string value stored at key
* - _group_: bitmap
* - _complexity_: O(1)
* - _since_: 2.2.0
*/
setbit(
key: RedisKey,
offset: number | string,
value: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Set the value and expiration of a key
* - _group_: string
* - _complexity_: O(1)
* - _since_: 2.0.0
*/
setex(
key: RedisKey,
seconds: number | string,
value: string | Buffer | number,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Set the value of a key, only if the key does not exist
* - _group_: string
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
setnx(
key: RedisKey,
value: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Overwrite part of a string at key starting at the specified offset
* - _group_: string
* - _complexity_: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
* - _since_: 2.2.0
*/
setrange(
key: RedisKey,
offset: number | string,
value: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Synchronously save the dataset to disk and then shut down the server
* - _group_: server
* - _complexity_: O(N) when saving, where N is the total number of keys in all databases when saving data, otherwise O(1)
* - _since_: 1.0.0
*/
shutdown(callback?: Callback<"OK">): Result<"OK", Context>;
shutdown(abort: "ABORT", callback?: Callback<"OK">): Result<"OK", Context>;
shutdown(force: "FORCE", callback?: Callback<"OK">): Result<"OK", Context>;
shutdown(
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(now: "NOW", callback?: Callback<"OK">): Result<"OK", Context>;
shutdown(
now: "NOW",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
now: "NOW",
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
now: "NOW",
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(nosave: "NOSAVE", callback?: Callback<"OK">): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
now: "NOW",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
now: "NOW",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
now: "NOW",
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
nosave: "NOSAVE",
now: "NOW",
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(save: "SAVE", callback?: Callback<"OK">): Result<"OK", Context>;
shutdown(
save: "SAVE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
save: "SAVE",
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
save: "SAVE",
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
save: "SAVE",
now: "NOW",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
save: "SAVE",
now: "NOW",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
save: "SAVE",
now: "NOW",
force: "FORCE",
callback?: Callback<"OK">
): Result<"OK", Context>;
shutdown(
save: "SAVE",
now: "NOW",
force: "FORCE",
abort: "ABORT",
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Intersect multiple sets
* - _group_: set
* - _complexity_: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
* - _since_: 1.0.0
*/
sinter(
...args: [...keys: RedisKey[], callback: Callback<string[]>]
): Result<string[], Context>;
sinterBuffer(
...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]
): Result<Buffer[], Context>;
sinter(
...args: [keys: RedisKey[], callback: Callback<string[]>]
): Result<string[], Context>;
sinterBuffer(
...args: [keys: RedisKey[], callback: Callback<Buffer[]>]
): Result<Buffer[], Context>;
sinter(...args: [...keys: RedisKey[]]): Result<string[], Context>;
sinterBuffer(...args: [...keys: RedisKey[]]): Result<Buffer[], Context>;
sinter(...args: [keys: RedisKey[]]): Result<string[], Context>;
sinterBuffer(...args: [keys: RedisKey[]]): Result<Buffer[], Context>;
/**
* Intersect multiple sets and return the cardinality of the result
* - _group_: set
* - _complexity_: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
* - _since_: 7.0.0
*/
sintercard(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sintercard(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sintercard(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<number, Context>;
sintercard(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<number, Context>;
sintercard(
...args: [
numkeys: number | string,
...keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string,
callback: Callback<number>
]
): Result<number, Context>;
sintercard(
...args: [
numkeys: number | string,
keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string,
callback: Callback<number>
]
): Result<number, Context>;
sintercard(
...args: [
numkeys: number | string,
...keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string
]
): Result<number, Context>;
sintercard(
...args: [
numkeys: number | string,
keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string
]
): Result<number, Context>;
/**
* Intersect multiple sets and store the resulting set in a key
* - _group_: set
* - _complexity_: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
* - _since_: 1.0.0
*/
sinterstore(
...args: [
destination: RedisKey,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sinterstore(
...args: [
destination: RedisKey,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sinterstore(
...args: [destination: RedisKey, ...keys: RedisKey[]]
): Result<number, Context>;
sinterstore(
...args: [destination: RedisKey, keys: RedisKey[]]
): Result<number, Context>;
/**
* Determine if a given value is a member of a set
* - _group_: set
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
sismember(
key: RedisKey,
member: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Make the server a replica of another instance, or promote it as master.
* - _group_: server
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
slaveof(
host: string | Buffer,
port: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Get the slow log's entries
* - _group_: server
* - _complexity_: O(N) where N is the number of entries returned
* - _since_: 2.2.12
*/
slowlog(
subcommand: "GET",
callback?: Callback<unknown>
): Result<unknown, Context>;
slowlog(
subcommand: "GET",
count: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: server
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
slowlog(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get the slow log's length
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.2.12
*/
slowlog(
subcommand: "LEN",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Clear all entries from the slow log
* - _group_: server
* - _complexity_: O(N) where N is the number of entries in the slowlog
* - _since_: 2.2.12
*/
slowlog(
subcommand: "RESET",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get all the members in a set
* - _group_: set
* - _complexity_: O(N) where N is the set cardinality.
* - _since_: 1.0.0
*/
smembers(
key: RedisKey,
callback?: Callback<string[]>
): Result<string[], Context>;
smembersBuffer(
key: RedisKey,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Returns the membership associated with the given elements for a set
* - _group_: set
* - _complexity_: O(N) where N is the number of elements being checked for membership
* - _since_: 6.2.0
*/
smismember(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<number[]>
]
): Result<number[], Context>;
smismember(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<number[]>
]
): Result<number[], Context>;
smismember(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<number[], Context>;
smismember(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<number[], Context>;
/**
* Move a member from one set to another
* - _group_: set
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
smove(
source: RedisKey,
destination: RedisKey,
member: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Sort the elements in a list, set or sorted set
* - _group_: generic
* - _complexity_: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
* - _since_: 1.0.0
*/
sort(
...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown>]
): Result<unknown, Context>;
sort(
...args: [key: RedisKey, ...args: RedisValue[]]
): Result<unknown, Context>;
/**
* Sort the elements in a list, set or sorted set. Read-only variant of SORT.
* - _group_: generic
* - _complexity_: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
* - _since_: 7.0.0
*/
sort_ro(
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
asc: "ASC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
asc: "ASC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
desc: "DESC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
desc: "DESC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
asc: "ASC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
asc: "ASC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
asc: "ASC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
asc: "ASC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
desc: "DESC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
desc: "DESC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
desc: "DESC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "GET",
...patterns: string[],
desc: "DESC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
asc: "ASC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
asc: "ASC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
desc: "DESC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
desc: "DESC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[]
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
asc: "ASC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
asc: "ASC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
asc: "ASC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
asc: "ASC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
desc: "DESC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
desc: "DESC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
desc: "DESC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken: "GET",
...patterns: string[],
desc: "DESC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
asc: "ASC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
asc: "ASC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
desc: "DESC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
desc: "DESC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[]
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
asc: "ASC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
asc: "ASC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
desc: "DESC",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
desc: "DESC",
alpha: "ALPHA",
callback?: Callback<unknown>
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[]
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
asc: "ASC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC"
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC",
alpha: "ALPHA",
callback: Callback<unknown>
]
): Result<unknown, Context>;
sort_ro(
...args: [
key: RedisKey,
patternToken: "BY",
pattern: string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
patternToken1: "GET",
...pattern1s: string[],
desc: "DESC",
alpha: "ALPHA"
]
): Result<unknown, Context>;
/**
* Remove and return one or multiple random members from a set
* - _group_: set
* - _complexity_: Without the count argument O(1), otherwise O(N) where N is the value of the passed count.
* - _since_: 1.0.0
*/
spop(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
spopBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
spop(
key: RedisKey,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
spopBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* 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
*/
spublish(
shardchannel: string | Buffer,
message: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* 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
*/
srandmember(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
srandmemberBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
srandmember(
key: RedisKey,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
srandmemberBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Remove one or more members from a set
* - _group_: set
* - _complexity_: O(N) where N is the number of members to be removed.
* - _since_: 1.0.0
*/
srem(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
srem(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
srem(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<number, Context>;
srem(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Incrementally iterate Set elements
* - _group_: set
* - _complexity_: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
* - _since_: 2.8.0
*/
sscan(
key: RedisKey,
cursor: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
sscanBuffer(
key: RedisKey,
cursor: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
sscan(
key: RedisKey,
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
sscanBuffer(
key: RedisKey,
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
sscan(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
sscanBuffer(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
sscan(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
sscanBuffer(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
/**
* Listen for messages published to the given shard channels
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of shard channels to subscribe to.
* - _since_: 7.0.0
*/
ssubscribe(
...args: [
...shardchannels: (string | Buffer)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
ssubscribe(
...args: [...shardchannels: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* Get the length of the value stored in a key
* - _group_: string
* - _complexity_: O(1)
* - _since_: 2.2.0
*/
strlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Listen for messages published to the given channels
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of channels to subscribe to.
* - _since_: 2.0.0
*/
subscribe(
...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]
): Result<unknown, Context>;
subscribe(
...args: [...channels: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* Get a substring of the string stored at a key
* - _group_: string
* - _complexity_: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
* - _since_: 1.0.0
*/
substr(
key: RedisKey,
start: number | string,
end: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Add multiple sets
* - _group_: set
* - _complexity_: O(N) where N is the total number of elements in all given sets.
* - _since_: 1.0.0
*/
sunion(
...args: [...keys: RedisKey[], callback: Callback<string[]>]
): Result<string[], Context>;
sunionBuffer(
...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]
): Result<Buffer[], Context>;
sunion(
...args: [keys: RedisKey[], callback: Callback<string[]>]
): Result<string[], Context>;
sunionBuffer(
...args: [keys: RedisKey[], callback: Callback<Buffer[]>]
): Result<Buffer[], Context>;
sunion(...args: [...keys: RedisKey[]]): Result<string[], Context>;
sunionBuffer(...args: [...keys: RedisKey[]]): Result<Buffer[], Context>;
sunion(...args: [keys: RedisKey[]]): Result<string[], Context>;
sunionBuffer(...args: [keys: RedisKey[]]): Result<Buffer[], Context>;
/**
* Add multiple sets and store the resulting set in a key
* - _group_: set
* - _complexity_: O(N) where N is the total number of elements in all given sets.
* - _since_: 1.0.0
*/
sunionstore(
...args: [
destination: RedisKey,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sunionstore(
...args: [
destination: RedisKey,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
sunionstore(
...args: [destination: RedisKey, ...keys: RedisKey[]]
): Result<number, Context>;
sunionstore(
...args: [destination: RedisKey, keys: RedisKey[]]
): Result<number, Context>;
/**
* Stop listening for messages posted to the given shard channels
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of clients already subscribed to a shard channel.
* - _since_: 7.0.0
*/
sunsubscribe(callback?: Callback<unknown>): Result<unknown, Context>;
sunsubscribe(
...args: [
...shardchannels: (string | Buffer)[],
callback: Callback<unknown>
]
): Result<unknown, Context>;
sunsubscribe(
...args: [...shardchannels: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* 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
*/
swapdb(
index1: number | string,
index2: number | string,
callback?: Callback<"OK">
): Result<"OK", Context>;
/**
* Internal command used for replication
* - _group_: server
* - _complexity_: undefined
* - _since_: 1.0.0
*/
sync(callback?: Callback<unknown>): Result<unknown, Context>;
/**
* Return the current server time
* - _group_: server
* - _complexity_: O(1)
* - _since_: 2.6.0
*/
time(callback?: Callback<number[]>): Result<number[], Context>;
/**
* Alters the last access time of a key(s). Returns the number of existing keys specified.
* - _group_: generic
* - _complexity_: O(N) where N is the number of keys that will be touched.
* - _since_: 3.2.1
*/
touch(
...args: [...keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
touch(
...args: [keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
touch(...args: [...keys: RedisKey[]]): Result<number, Context>;
touch(...args: [keys: RedisKey[]]): Result<number, Context>;
/**
* Get the time to live for a key in seconds
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
ttl(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Determine the type stored at key
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 1.0.0
*/
type(key: RedisKey, callback?: Callback<string>): Result<string, Context>;
/**
* Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
* - _group_: generic
* - _complexity_: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
* - _since_: 4.0.0
*/
unlink(
...args: [...keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
unlink(
...args: [keys: RedisKey[], callback: Callback<number>]
): Result<number, Context>;
unlink(...args: [...keys: RedisKey[]]): Result<number, Context>;
unlink(...args: [keys: RedisKey[]]): Result<number, Context>;
/**
* Stop listening for messages posted to the given channels
* - _group_: pubsub
* - _complexity_: O(N) where N is the number of clients already subscribed to a channel.
* - _since_: 2.0.0
*/
unsubscribe(callback?: Callback<unknown>): Result<unknown, Context>;
unsubscribe(
...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]
): Result<unknown, Context>;
unsubscribe(
...args: [...channels: (string | Buffer)[]]
): Result<unknown, Context>;
/**
* Forget about all watched keys
* - _group_: transactions
* - _complexity_: O(1)
* - _since_: 2.2.0
*/
unwatch(callback?: Callback<"OK">): Result<"OK", Context>;
/**
* Wait for the synchronous replication of all the write commands sent in the context of the current connection
* - _group_: generic
* - _complexity_: O(1)
* - _since_: 3.0.0
*/
wait(
numreplicas: number | string,
timeout: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Watch the given keys to determine execution of the MULTI/EXEC block
* - _group_: transactions
* - _complexity_: O(1) for every key.
* - _since_: 2.2.0
*/
watch(
...args: [...keys: RedisKey[], callback: Callback<"OK">]
): Result<"OK", Context>;
watch(
...args: [keys: RedisKey[], callback: Callback<"OK">]
): Result<"OK", Context>;
watch(...args: [...keys: RedisKey[]]): Result<"OK", Context>;
watch(...args: [keys: RedisKey[]]): Result<"OK", Context>;
/**
* Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.
* - _group_: stream
* - _complexity_: O(1) for each message ID processed.
* - _since_: 5.0.0
*/
xack(
...args: [
key: RedisKey,
group: string | Buffer,
...ids: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
xack(
...args: [
key: RedisKey,
group: string | Buffer,
...ids: (string | Buffer | number)[]
]
): Result<number, Context>;
/**
* Appends a new entry to a stream
* - _group_: stream
* - _complexity_: O(1) when adding a new entry, O(N) when trimming where N being the number of entries evicted.
* - _since_: 5.0.0
*/
xadd(
...args: [
key: RedisKey,
...args: RedisValue[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
xaddBuffer(
...args: [
key: RedisKey,
...args: RedisValue[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
xadd(
...args: [key: RedisKey, ...args: RedisValue[]]
): Result<string | null, Context>;
xaddBuffer(
...args: [key: RedisKey, ...args: RedisValue[]]
): Result<Buffer | null, Context>;
/**
* Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
* - _group_: stream
* - _complexity_: O(1) if COUNT is small.
* - _since_: 6.2.0
*/
xautoclaim(
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
start: string | Buffer | number,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xautoclaim(
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
start: string | Buffer | number,
justid: "JUSTID",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xautoclaim(
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
start: string | Buffer | number,
countToken: "COUNT",
count: number | string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xautoclaim(
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
start: string | Buffer | number,
countToken: "COUNT",
count: number | string,
justid: "JUSTID",
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
* - _group_: stream
* - _complexity_: O(log N) with N being the number of messages in the PEL of the consumer group.
* - _since_: 5.0.0
*/
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[]
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
justid: "JUSTID"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE"
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID",
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xclaim(
...args: [
key: RedisKey,
group: string | Buffer,
consumer: string | Buffer,
minIdleTime: string | Buffer | number,
...ids: (string | Buffer | number)[],
msToken: "IDLE",
ms: number | string,
unixTimeMillisecondsToken: "TIME",
unixTimeMilliseconds: number | string,
countToken: "RETRYCOUNT",
count: number | string,
force: "FORCE",
justid: "JUSTID"
]
): Result<unknown[], Context>;
/**
* Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.
* - _group_: stream
* - _complexity_: O(1) for each single item to delete in the stream, regardless of the stream size.
* - _since_: 5.0.0
*/
xdel(
...args: [
key: RedisKey,
...ids: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
xdel(
...args: [key: RedisKey, ...ids: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Create a consumer group.
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
id: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
id: string | Buffer | number,
entriesReadToken: "ENTRIESREAD",
entriesRead: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
id: string | Buffer | number,
mkstream: "MKSTREAM",
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
id: string | Buffer | number,
mkstream: "MKSTREAM",
entriesReadToken: "ENTRIESREAD",
entriesRead: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
newId: "$",
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
newId: "$",
entriesReadToken: "ENTRIESREAD",
entriesRead: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
newId: "$",
mkstream: "MKSTREAM",
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "CREATE",
key: RedisKey,
groupname: string | Buffer,
newId: "$",
mkstream: "MKSTREAM",
entriesReadToken: "ENTRIESREAD",
entriesRead: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Create a consumer in a consumer group.
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 6.2.0
*/
xgroup(
subcommand: "CREATECONSUMER",
key: RedisKey,
groupname: string | Buffer,
consumername: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Delete a consumer from a consumer group.
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xgroup(
subcommand: "DELCONSUMER",
key: RedisKey,
groupname: string | Buffer,
consumername: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Destroy a consumer group.
* - _group_: stream
* - _complexity_: O(N) where N is the number of entries in the group's pending entries list (PEL).
* - _since_: 5.0.0
*/
xgroup(
subcommand: "DESTROY",
key: RedisKey,
groupname: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xgroup(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Set a consumer group to an arbitrary last delivered ID value.
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xgroup(
subcommand: "SETID",
key: RedisKey,
groupname: string | Buffer,
id: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "SETID",
key: RedisKey,
groupname: string | Buffer,
id: string | Buffer | number,
entriesReadToken: "ENTRIESREAD",
entriesRead: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "SETID",
key: RedisKey,
groupname: string | Buffer,
newId: "$",
callback?: Callback<unknown>
): Result<unknown, Context>;
xgroup(
subcommand: "SETID",
key: RedisKey,
groupname: string | Buffer,
newId: "$",
entriesReadToken: "ENTRIESREAD",
entriesRead: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* List the consumers in a consumer group
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xinfo(
subcommand: "CONSUMERS",
key: RedisKey,
groupname: string | Buffer,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* List the consumer groups of a stream
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xinfo(
subcommand: "GROUPS",
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Show helpful text about the different subcommands
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xinfo(
subcommand: "HELP",
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Get information about a stream
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xinfo(
subcommand: "STREAM",
key: RedisKey,
callback?: Callback<unknown>
): Result<unknown, Context>;
xinfo(
subcommand: "STREAM",
key: RedisKey,
fullToken: "FULL",
callback?: Callback<unknown>
): Result<unknown, Context>;
xinfo(
subcommand: "STREAM",
key: RedisKey,
fullToken: "FULL",
countToken: "COUNT",
count: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Return the number of entries in a stream
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xlen(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
* - _group_: stream
* - _complexity_: O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.
* - _since_: 5.0.0
*/
xpending(
key: RedisKey,
group: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xpending(
key: RedisKey,
group: string | Buffer,
start: string | Buffer | number,
end: string | Buffer | number,
count: number | string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xpending(
key: RedisKey,
group: string | Buffer,
start: string | Buffer | number,
end: string | Buffer | number,
count: number | string,
consumer: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xpending(
key: RedisKey,
group: string | Buffer,
minIdleTimeToken: "IDLE",
minIdleTime: number | string,
start: string | Buffer | number,
end: string | Buffer | number,
count: number | string,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
xpending(
key: RedisKey,
group: string | Buffer,
minIdleTimeToken: "IDLE",
minIdleTime: number | string,
start: string | Buffer | number,
end: string | Buffer | number,
count: number | string,
consumer: string | Buffer,
callback?: Callback<unknown[]>
): Result<unknown[], Context>;
/**
* Return a range of elements in a stream, with IDs matching the specified IDs interval
* - _group_: stream
* - _complexity_: O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
* - _since_: 5.0.0
*/
xrange(
key: RedisKey,
start: string | Buffer | number,
end: string | Buffer | number,
callback?: Callback<[id: string, fields: string[]][]>
): Result<[id: string, fields: string[]][], Context>;
xrangeBuffer(
key: RedisKey,
start: string | Buffer | number,
end: string | Buffer | number,
callback?: Callback<[id: Buffer, fields: Buffer[]][]>
): Result<[id: Buffer, fields: Buffer[]][], Context>;
xrange(
key: RedisKey,
start: string | Buffer | number,
end: string | Buffer | number,
countToken: "COUNT",
count: number | string,
callback?: Callback<[id: string, fields: string[]][]>
): Result<[id: string, fields: string[]][], Context>;
xrangeBuffer(
key: RedisKey,
start: string | Buffer | number,
end: string | Buffer | number,
countToken: "COUNT",
count: number | string,
callback?: Callback<[id: Buffer, fields: Buffer[]][]>
): Result<[id: Buffer, fields: Buffer[]][], Context>;
/**
* Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.
* - _group_: stream
* - _complexity_: For each stream mentioned: O(N) with N being the number of elements being returned, it means that XREAD-ing with a fixed COUNT is O(1). Note that when the BLOCK option is used, XADD will pay O(M) time in order to serve the M clients blocked on the stream getting new data.
* - _since_: 5.0.0
*/
xread(
...args: [
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: string, items: [id: string, fields: string[]][]][] | null
>
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null
>
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [streamsToken: "STREAMS", ...args: RedisValue[]]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [streamsToken: "STREAMS", ...args: RedisValue[]]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: string, items: [id: string, fields: string[]][]][] | null
>
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null
>
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [
countToken: "COUNT",
count: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: string, items: [id: string, fields: string[]][]][] | null
>
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
countToken: "COUNT",
count: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null
>
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [
countToken: "COUNT",
count: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
countToken: "COUNT",
count: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: string, items: [id: string, fields: string[]][]][] | null
>
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null
>
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
xread(
...args: [
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<
[key: string, items: [id: string, fields: string[]][]][] | null,
Context
>;
xreadBuffer(
...args: [
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<
[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
Context
>;
/**
* Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.
* - _group_: stream
* - _complexity_: For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.
* - _since_: 5.0.0
*/
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
millisecondsToken: "BLOCK",
milliseconds: number | string,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
millisecondsToken: "BLOCK",
milliseconds: number | string,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[],
callback: Callback<unknown[]>
]
): Result<unknown[], Context>;
xreadgroup(
...args: [
groupConsumerToken: "GROUP",
group: string | Buffer,
consumer: string | Buffer,
countToken: "COUNT",
count: number | string,
millisecondsToken: "BLOCK",
milliseconds: number | string,
noack: "NOACK",
streamsToken: "STREAMS",
...args: RedisValue[]
]
): Result<unknown[], Context>;
/**
* Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE
* - _group_: stream
* - _complexity_: O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
* - _since_: 5.0.0
*/
xrevrange(
key: RedisKey,
end: string | Buffer | number,
start: string | Buffer | number,
callback?: Callback<[id: string, fields: string[]][]>
): Result<[id: string, fields: string[]][], Context>;
xrevrangeBuffer(
key: RedisKey,
end: string | Buffer | number,
start: string | Buffer | number,
callback?: Callback<[id: Buffer, fields: Buffer[]][]>
): Result<[id: Buffer, fields: Buffer[]][], Context>;
xrevrange(
key: RedisKey,
end: string | Buffer | number,
start: string | Buffer | number,
countToken: "COUNT",
count: number | string,
callback?: Callback<[id: string, fields: string[]][]>
): Result<[id: string, fields: string[]][], Context>;
xrevrangeBuffer(
key: RedisKey,
end: string | Buffer | number,
start: string | Buffer | number,
countToken: "COUNT",
count: number | string,
callback?: Callback<[id: Buffer, fields: Buffer[]][]>
): Result<[id: Buffer, fields: Buffer[]][], Context>;
/**
* An internal command for replicating stream values
* - _group_: stream
* - _complexity_: O(1)
* - _since_: 5.0.0
*/
xsetid(
key: RedisKey,
lastId: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
xsetid(
key: RedisKey,
lastId: string | Buffer | number,
maxDeletedEntryIdToken: "MAXDELETEDID",
maxDeletedEntryId: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
xsetid(
key: RedisKey,
lastId: string | Buffer | number,
entriesAddedToken: "ENTRIESADDED",
entriesAdded: number | string,
callback?: Callback<unknown>
): Result<unknown, Context>;
xsetid(
key: RedisKey,
lastId: string | Buffer | number,
entriesAddedToken: "ENTRIESADDED",
entriesAdded: number | string,
maxDeletedEntryIdToken: "MAXDELETEDID",
maxDeletedEntryId: string | Buffer | number,
callback?: Callback<unknown>
): Result<unknown, Context>;
/**
* Trims the stream to (approximately if '~' is passed) a certain size
* - _group_: stream
* - _complexity_: O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.
* - _since_: 5.0.0
*/
xtrim(
key: RedisKey,
maxlen: "MAXLEN",
threshold: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
maxlen: "MAXLEN",
threshold: string | Buffer | number,
countToken: "LIMIT",
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
maxlen: "MAXLEN",
equal: "=",
threshold: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
maxlen: "MAXLEN",
equal: "=",
threshold: string | Buffer | number,
countToken: "LIMIT",
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
maxlen: "MAXLEN",
approximately: "~",
threshold: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
maxlen: "MAXLEN",
approximately: "~",
threshold: string | Buffer | number,
countToken: "LIMIT",
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
minid: "MINID",
threshold: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
minid: "MINID",
threshold: string | Buffer | number,
countToken: "LIMIT",
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
minid: "MINID",
equal: "=",
threshold: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
minid: "MINID",
equal: "=",
threshold: string | Buffer | number,
countToken: "LIMIT",
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
minid: "MINID",
approximately: "~",
threshold: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
xtrim(
key: RedisKey,
minid: "MINID",
approximately: "~",
threshold: string | Buffer | number,
countToken: "LIMIT",
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Add one or more members to a sorted set, or update its score if it already exists
* - _group_: sorted-set
* - _complexity_: O(log(N)) for each item added, where N is the number of elements in the sorted set.
* - _since_: 1.2.0
*/
zadd(
...args: [
key: RedisKey,
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [key: RedisKey, ...scoreMembers: (string | Buffer | number)[]]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string>
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer>
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string, Context>;
zaddBuffer(
...args: [
key: RedisKey,
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
nx: "NX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
gt: "GT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
ch: "CH",
...scoreMembers: (string | Buffer | number)[]
]
): Result<number, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<string | null>
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[],
callback: Callback<Buffer | null>
]
): Result<Buffer | null, Context>;
zadd(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<string | null, Context>;
zaddBuffer(
...args: [
key: RedisKey,
xx: "XX",
lt: "LT",
ch: "CH",
incr: "INCR",
...scoreMembers: (string | Buffer | number)[]
]
): Result<Buffer | null, Context>;
/**
* Get the number of members in a sorted set
* - _group_: sorted-set
* - _complexity_: O(1)
* - _since_: 1.2.0
*/
zcard(key: RedisKey, callback?: Callback<number>): Result<number, Context>;
/**
* Count the members in a sorted set with scores within the given values
* - _group_: sorted-set
* - _complexity_: O(log(N)) with N being the number of elements in the sorted set.
* - _since_: 2.0.0
*/
zcount(
key: RedisKey,
min: number | string,
max: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Subtract multiple sorted sets
* - _group_: sorted-set
* - _complexity_: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
* - _since_: 6.2.0
*/
zdiff(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zdiffBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zdiff(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zdiffBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zdiff(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<string[], Context>;
zdiffBuffer(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<Buffer[], Context>;
zdiff(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<string[], Context>;
zdiffBuffer(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<Buffer[], Context>;
zdiff(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zdiffBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zdiff(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zdiffBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zdiff(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zdiffBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zdiff(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zdiffBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
/**
* Subtract multiple sorted sets and store the resulting sorted set in a new key
* - _group_: sorted-set
* - _complexity_: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
* - _since_: 6.2.0
*/
zdiffstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zdiffstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zdiffstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[]
]
): Result<number, Context>;
zdiffstore(
...args: [destination: RedisKey, numkeys: number | string, keys: RedisKey[]]
): Result<number, Context>;
/**
* Increment the score of a member in a sorted set
* - _group_: sorted-set
* - _complexity_: O(log(N)) where N is the number of elements in the sorted set.
* - _since_: 1.2.0
*/
zincrby(
key: RedisKey,
increment: number | string,
member: string | Buffer | number,
callback?: Callback<string>
): Result<string, Context>;
zincrbyBuffer(
key: RedisKey,
increment: number | string,
member: string | Buffer | number,
callback?: Callback<Buffer>
): Result<Buffer, Context>;
/**
* Intersect multiple sorted sets
* - _group_: sorted-set
* - _complexity_: O(N*K)+O(M*log(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
*/
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<string[], Context>;
zinterBuffer(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<Buffer[], Context>;
zinter(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<string[], Context>;
zinterBuffer(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [numkeys: number | string, ...args: RedisValue[]]
): Result<string[], Context>;
zinterBuffer(
...args: [numkeys: number | string, ...args: RedisValue[]]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zinter(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zinterBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
/**
* Intersect multiple sorted sets and return the cardinality of the result
* - _group_: sorted-set
* - _complexity_: O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets.
* - _since_: 7.0.0
*/
zintercard(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zintercard(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zintercard(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<number, Context>;
zintercard(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<number, Context>;
zintercard(
...args: [
numkeys: number | string,
...keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string,
callback: Callback<number>
]
): Result<number, Context>;
zintercard(
...args: [
numkeys: number | string,
keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string,
callback: Callback<number>
]
): Result<number, Context>;
zintercard(
...args: [
numkeys: number | string,
...keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string
]
): Result<number, Context>;
zintercard(
...args: [
numkeys: number | string,
keys: RedisKey[],
limitToken: "LIMIT",
limit: number | string
]
): Result<number, Context>;
/**
* Intersect multiple sorted sets and store the resulting sorted set in a new key
* - _group_: sorted-set
* - _complexity_: O(N*K)+O(M*log(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
*/
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[]
]
): Result<number, Context>;
zinterstore(
...args: [destination: RedisKey, numkeys: number | string, keys: RedisKey[]]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[]
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<number>
]
): Result<number, Context>;
zinterstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<number, Context>;
/**
* Count the number of members in a sorted set between a given lexicographical range
* - _group_: sorted-set
* - _complexity_: O(log(N)) with N being the number of elements in the sorted set.
* - _since_: 2.8.9
*/
zlexcount(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Remove and return members with scores in a sorted set
* - _group_: sorted-set
* - _complexity_: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
* - _since_: 7.0.0
*/
zmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
min: "MIN",
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
min: "MIN",
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [numkeys: number | string, ...keys: RedisKey[], min: "MIN"]
): Result<unknown, Context>;
zmpop(
...args: [numkeys: number | string, keys: RedisKey[], min: "MIN"]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
min: "MIN",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
max: "MAX",
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
max: "MAX",
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [numkeys: number | string, ...keys: RedisKey[], max: "MAX"]
): Result<unknown, Context>;
zmpop(
...args: [numkeys: number | string, keys: RedisKey[], max: "MAX"]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string,
callback: Callback<unknown>
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
...keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
zmpop(
...args: [
numkeys: number | string,
keys: RedisKey[],
max: "MAX",
countToken: "COUNT",
count: number | string
]
): Result<unknown, Context>;
/**
* Get the score associated with the given members in a sorted set
* - _group_: sorted-set
* - _complexity_: O(N) where N is the number of members being requested.
* - _since_: 6.2.0
*/
zmscore(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<(string | null)[]>
]
): Result<(string | null)[], Context>;
zmscoreBuffer(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<(Buffer | null)[]>
]
): Result<(Buffer | null)[], Context>;
zmscore(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<(string | null)[]>
]
): Result<(string | null)[], Context>;
zmscoreBuffer(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<(Buffer | null)[]>
]
): Result<(Buffer | null)[], Context>;
zmscore(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<(string | null)[], Context>;
zmscoreBuffer(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<(Buffer | null)[], Context>;
zmscore(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<(string | null)[], Context>;
zmscoreBuffer(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<(Buffer | null)[], Context>;
/**
* Remove and return members with the highest scores in a sorted set
* - _group_: sorted-set
* - _complexity_: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
* - _since_: 5.0.0
*/
zpopmax(
key: RedisKey,
callback?: Callback<string[]>
): Result<string[], Context>;
zpopmaxBuffer(
key: RedisKey,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zpopmax(
key: RedisKey,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zpopmaxBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Remove and return members with the lowest scores in a sorted set
* - _group_: sorted-set
* - _complexity_: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
* - _since_: 5.0.0
*/
zpopmin(
key: RedisKey,
callback?: Callback<string[]>
): Result<string[], Context>;
zpopminBuffer(
key: RedisKey,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zpopmin(
key: RedisKey,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zpopminBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Get one or multiple random elements from a sorted set
* - _group_: sorted-set
* - _complexity_: O(N) where N is the number of elements returned
* - _since_: 6.2.0
*/
zrandmember(
key: RedisKey,
callback?: Callback<string | null>
): Result<string | null, Context>;
zrandmemberBuffer(
key: RedisKey,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
zrandmember(
key: RedisKey,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrandmemberBuffer(
key: RedisKey,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrandmember(
key: RedisKey,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrandmemberBuffer(
key: RedisKey,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Return a range of members in a sorted set
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
* - _since_: 1.2.0
*/
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrange(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangeBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Return a range of members in a sorted set, by lexicographical range
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
* - _since_: 2.8.9
*/
zrangebylex(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangebylexBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrangebylex(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangebylexBuffer(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Return a range of members in a sorted set, by score
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
* - _since_: 1.0.5
*/
zrangebyscore(
key: RedisKey,
min: number | string,
max: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangebyscoreBuffer(
key: RedisKey,
min: number | string,
max: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrangebyscore(
key: RedisKey,
min: number | string,
max: number | string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangebyscoreBuffer(
key: RedisKey,
min: number | string,
max: number | string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrangebyscore(
key: RedisKey,
min: number | string,
max: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrangebyscoreBuffer(
key: RedisKey,
min: number | string,
max: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrangebyscore(
key: RedisKey,
min: number | string,
max: number | string,
withscores: "WITHSCORES",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrangebyscoreBuffer(
key: RedisKey,
min: number | string,
max: number | string,
withscores: "WITHSCORES",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Store a range of members from sorted set into another key
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements stored into the destination key.
* - _since_: 6.2.0
*/
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
byscore: "BYSCORE",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
callback?: Callback<number>
): Result<number, Context>;
zrangestore(
dst: RedisKey,
src: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
bylex: "BYLEX",
rev: "REV",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Determine the index of a member in a sorted set
* - _group_: sorted-set
* - _complexity_: O(log(N))
* - _since_: 2.0.0
*/
zrank(
key: RedisKey,
member: string | Buffer | number,
callback?: Callback<number | null>
): Result<number | null, Context>;
/**
* Remove one or more members from a sorted set
* - _group_: sorted-set
* - _complexity_: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
* - _since_: 1.2.0
*/
zrem(
...args: [
key: RedisKey,
...members: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zrem(
...args: [
key: RedisKey,
members: (string | Buffer | number)[],
callback: Callback<number>
]
): Result<number, Context>;
zrem(
...args: [key: RedisKey, ...members: (string | Buffer | number)[]]
): Result<number, Context>;
zrem(
...args: [key: RedisKey, members: (string | Buffer | number)[]]
): Result<number, Context>;
/**
* Remove all members in a sorted set between the given lexicographical range
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
* - _since_: 2.8.9
*/
zremrangebylex(
key: RedisKey,
min: string | Buffer | number,
max: string | Buffer | number,
callback?: Callback<number>
): Result<number, Context>;
/**
* Remove all members in a sorted set within the given indexes
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
* - _since_: 2.0.0
*/
zremrangebyrank(
key: RedisKey,
start: number | string,
stop: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Remove all members in a sorted set within the given scores
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
* - _since_: 1.2.0
*/
zremrangebyscore(
key: RedisKey,
min: number | string,
max: number | string,
callback?: Callback<number>
): Result<number, Context>;
/**
* Return a range of members in a sorted set, by index, with scores ordered from high to low
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
* - _since_: 1.2.0
*/
zrevrange(
key: RedisKey,
start: number | string,
stop: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangeBuffer(
key: RedisKey,
start: number | string,
stop: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrevrange(
key: RedisKey,
start: number | string,
stop: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangeBuffer(
key: RedisKey,
start: number | string,
stop: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
* - _since_: 2.8.9
*/
zrevrangebylex(
key: RedisKey,
max: string | Buffer | number,
min: string | Buffer | number,
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangebylexBuffer(
key: RedisKey,
max: string | Buffer | number,
min: string | Buffer | number,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrevrangebylex(
key: RedisKey,
max: string | Buffer | number,
min: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangebylexBuffer(
key: RedisKey,
max: string | Buffer | number,
min: string | Buffer | number,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Return a range of members in a sorted set, by score, with scores ordered from high to low
* - _group_: sorted-set
* - _complexity_: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
* - _since_: 2.2.0
*/
zrevrangebyscore(
key: RedisKey,
max: number | string,
min: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangebyscoreBuffer(
key: RedisKey,
max: number | string,
min: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrevrangebyscore(
key: RedisKey,
max: number | string,
min: number | string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangebyscoreBuffer(
key: RedisKey,
max: number | string,
min: number | string,
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrevrangebyscore(
key: RedisKey,
max: number | string,
min: number | string,
withscores: "WITHSCORES",
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangebyscoreBuffer(
key: RedisKey,
max: number | string,
min: number | string,
withscores: "WITHSCORES",
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
zrevrangebyscore(
key: RedisKey,
max: number | string,
min: number | string,
withscores: "WITHSCORES",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<string[]>
): Result<string[], Context>;
zrevrangebyscoreBuffer(
key: RedisKey,
max: number | string,
min: number | string,
withscores: "WITHSCORES",
offsetCountToken: "LIMIT",
offset: number | string,
count: number | string,
callback?: Callback<Buffer[]>
): Result<Buffer[], Context>;
/**
* Determine the index of a member in a sorted set, with scores ordered from high to low
* - _group_: sorted-set
* - _complexity_: O(log(N))
* - _since_: 2.0.0
*/
zrevrank(
key: RedisKey,
member: string | Buffer | number,
callback?: Callback<number | null>
): Result<number | null, Context>;
/**
* Incrementally iterate sorted sets elements and associated scores
* - _group_: sorted-set
* - _complexity_: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
* - _since_: 2.8.0
*/
zscan(
key: RedisKey,
cursor: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
zscanBuffer(
key: RedisKey,
cursor: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
zscan(
key: RedisKey,
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
zscanBuffer(
key: RedisKey,
cursor: number | string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
zscan(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
zscanBuffer(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
zscan(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: string, elements: string[]]>
): Result<[cursor: string, elements: string[]], Context>;
zscanBuffer(
key: RedisKey,
cursor: number | string,
patternToken: "MATCH",
pattern: string,
countToken: "COUNT",
count: number | string,
callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
): Result<[cursor: Buffer, elements: Buffer[]], Context>;
/**
* Get the score associated with the given member in a sorted set
* - _group_: sorted-set
* - _complexity_: O(1)
* - _since_: 1.2.0
*/
zscore(
key: RedisKey,
member: string | Buffer | number,
callback?: Callback<string | null>
): Result<string | null, Context>;
zscoreBuffer(
key: RedisKey,
member: string | Buffer | number,
callback?: Callback<Buffer | null>
): Result<Buffer | null, Context>;
/**
* Add multiple sorted sets
* - _group_: sorted-set
* - _complexity_: O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
* - _since_: 6.2.0
*/
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<string[], Context>;
zunionBuffer(
...args: [numkeys: number | string, ...keys: RedisKey[]]
): Result<Buffer[], Context>;
zunion(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<string[], Context>;
zunionBuffer(
...args: [numkeys: number | string, keys: RedisKey[]]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [numkeys: number | string, ...args: RedisValue[]]
): Result<string[], Context>;
zunionBuffer(
...args: [numkeys: number | string, ...args: RedisValue[]]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<string[]>
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES",
callback: Callback<Buffer[]>
]
): Result<Buffer[], Context>;
zunion(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<string[], Context>;
zunionBuffer(
...args: [
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
withscores: "WITHSCORES"
]
): Result<Buffer[], Context>;
/**
* Add multiple sorted sets and store the resulting sorted set in a new key
* - _group_: sorted-set
* - _complexity_: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
* - _since_: 2.0.0
*/
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[]
]
): Result<number, Context>;
zunionstore(
...args: [destination: RedisKey, numkeys: number | string, keys: RedisKey[]]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
keys: RedisKey[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[]
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
sum: "SUM"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
min: "MIN"
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX",
callback: Callback<number>
]
): Result<number, Context>;
zunionstore(
...args: [
destination: RedisKey,
numkeys: number | string,
...args: RedisValue[],
aggregate: "AGGREGATE",
max: "MAX"
]
): Result<number, Context>;
}
export default RedisCommander;