ioredis

ioredis

Version 5.4.1
Published 3 months ago
698 kB
9 dependencies
MIT license

Install

npm i ioredis

yarn add ioredis

pnpm add ioredis

Overview

A robust, performance-focused and full-featured Redis client for Node.js.

Index

Variables

variable ReplyError

const ReplyError: any;

Functions

function print

print: (err: Error | null, reply?: any) => void;

Classes

class AbstractConnector

abstract class AbstractConnector {}

constructor

constructor(disconnectTimeout: number);

property connecting

protected connecting: boolean;

property firstError

firstError?: Error;

property stream

protected stream: any;

method check

check: (info: any) => boolean;

method connect

abstract connect: (_: ErrorEmitter) => Promise<NetStream>;

method disconnect

disconnect: () => void;

class Cluster

class Cluster extends Commander {}

Client for the official Redis Cluster

constructor

constructor(startupNodes: ClusterNode[], options?: ClusterOptions);

Creates an instance of Cluster.

property autoPipelineQueueSize

readonly autoPipelineQueueSize: number;

Get the number of commands queued in automatic pipelines.
This is not available (and returns 0) until the cluster is connected and slots information have been received.

property isCluster

isCluster: boolean;

property options

options: ClusterOptions;

property slots

slots: string[][];

property status

status: ClusterStatus;

method connect

connect: () => Promise<void>;

Connect to a cluster

method delayUntilReady

delayUntilReady: (callback: Callback) => void;

This is needed in order not to install a listener for each auto pipeline

method disconnect

disconnect: (reconnect?: boolean) => void;

Disconnect from every node in the cluster.

method duplicate

duplicate: (overrideStartupNodes?: any[], overrideOptions?: {}) => Cluster;

Create a new instance with the same startup nodes and options as the current one.

Example 1

var cluster = new Redis.Cluster([{ host: "127.0.0.1", port: "30001" }]);
var anotherCluster = cluster.duplicate();

method handleError

handleError: (error: Error, ttl: { value?: any }, handlers: any) => void;

method hscanBufferStream

hscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method hscanStream

hscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method nodes

nodes: (role?: NodeRole) => Redis[];

Get nodes with the specified role

method quit

quit: (callback?: Callback<'OK'>) => Promise<'OK'>;

Quit the cluster gracefully.

method refreshSlotsCache

refreshSlotsCache: (callback?: Callback<void>) => void;

Refresh the slot cache

method sendCommand

sendCommand: (command: Command, stream?: WriteableStream, node?: any) => unknown;

method sscanBufferStream

sscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method sscanStream

sscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanBufferStream

zscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanStream

zscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

class Command

class Command implements Respondable {}

Command instance

It's rare that you need to create a Command instance yourself.

var infoCommand = new Command('info', null, function (err, result) {
  console.log('result', result);
});

redis.sendCommand(infoCommand);

// When no callback provided, Command instance will have a `promise` property,
// which will resolve/reject with the result of the command.
var getCommand = new Command('get', ['foo']);
getCommand.promise.then(function (result) {
  console.log('result', result);
});

constructor

constructor(
    name: string,
    args?: any[],
    options?: CommandOptions,
    callback?: Callback<any>
);

Creates an instance of Command.
Parameter name
Command name
Parameter args
An array of command arguments
Parameter options
Parameter callback
The callback that handles the response. If omit, the response will be handled via Promise

property args

args: any[];

property FLAGS

static FLAGS: {
    VALID_IN_SUBSCRIBER_MODE: [
        'subscribe',
        'psubscribe',
        'unsubscribe',
        'punsubscribe',
        'ssubscribe',
        'sunsubscribe',
        'ping',
        'quit'
    ];
    VALID_IN_MONITOR_MODE: ['monitor', 'auth'];
    ENTER_SUBSCRIBER_MODE: ['subscribe', 'psubscribe', 'ssubscribe'];
    EXIT_SUBSCRIBER_MODE: ['unsubscribe', 'punsubscribe', 'sunsubscribe'];
    WILL_DISCONNECT: ['quit'];
};

property ignore

ignore?: boolean;

property inTransaction

inTransaction: boolean;

property isReadOnly

isReadOnly?: boolean;

property isResolved

isResolved: boolean;

property name

name: string;

property pipelineIndex

pipelineIndex?: number;

property promise

promise: Promise<any>;

property reject

reject: (err: Error) => void;

property resolve

resolve: (result: any) => void;

method checkFlag

static checkFlag: <T extends keyof CommandNameFlags>(
    flagName: T,
    commandName: string
) => commandName is CommandNameFlags[T][number];

Check whether the command has the flag

method getKeys

getKeys: () => Array<string | Buffer>;

method getSlot

getSlot: () => number;

method setArgumentTransformer

static setArgumentTransformer: (name: string, func: ArgumentTransformer) => void;

method setReplyTransformer

static setReplyTransformer: (name: string, func: ReplyTransformer) => void;

method setTimeout

setTimeout: (ms: number) => void;

Set the wait time before terminating the attempt to execute a command and generating an error.

method stringifyArguments

stringifyArguments: () => void;

method toWritable

toWritable: (_socket: object) => string | Buffer;

Convert command to writable buffer or string

method transformReply

transformReply: (
    result: Buffer | Buffer[]
) => string | string[] | Buffer | Buffer[];

Convert buffer/buffer[] to string/string[], and apply reply transformer.

class Pipeline

class Pipeline extends Commander<{
    type: 'pipeline';
}> {}

constructor

constructor(redis: Cluster | Redis);

property isCluster

isCluster: boolean;

property isPipeline

isPipeline: boolean;

property leftRedirections

leftRedirections: { value?: number };

property promise

promise: Promise<unknown>;

property redis

redis: Cluster | Redis;

property reject

reject: (error: Error) => void;

property resolve

resolve: (result: unknown) => void;

method addBatch

addBatch: (commands: any) => this;

method fillResult

fillResult: (value: unknown[], position: number) => void;

method sendCommand

sendCommand: (command: Command) => unknown;

class Redis

class Redis extends Commander implements DataHandledable {}

This is the major component of ioredis. Use it to connect to a standalone Redis server or Sentinels.

const redis = new Redis(); // Default port is 6379
async function main() {
  redis.set("foo", "bar");
  redis.get("foo", (err, result) => {
    // `result` should be "bar"
    console.log(err, result);
  });
  // Or use Promise
  const result = await redis.get("foo");
}

constructor

constructor(port: number, host: string, options: RedisOptions);

constructor

constructor(path: string, options: RedisOptions);

constructor

constructor(port: number, options: RedisOptions);

constructor

constructor(port: number, host: string);

constructor

constructor(options: RedisOptions);

constructor

constructor(port: number);

constructor

constructor(path: string);

constructor

constructor();

property autoPipelineQueueSize

readonly autoPipelineQueueSize: number;

property Cluster

static Cluster: typeof Cluster;

property Command

static Command: typeof Command;

property commandQueue

commandQueue: Deque<CommandItem>;

property condition

condition: Condition;

property isCluster

isCluster: boolean;

property mode

readonly mode: 'normal' | 'subscriber' | 'monitor';

Mode of the connection.
One of "normal", "subscriber", or "monitor". When the connection is not in "normal" mode, certain commands are not allowed.

property options

options: RedisOptions;

property status

status: RedisStatus;

property stream

stream: any;

method connect

connect: (callback?: Callback<void>) => Promise<void>;

Create a connection to Redis. This method will be invoked automatically when creating a new Redis instance unless lazyConnect: true is passed.
When calling this method manually, a Promise is returned, which will be resolved when the connection status is ready.

method createClient

static createClient: () => Redis;

Create a Redis instance. This is the same as new Redis() but is included for compatibility with node-redis.

method disconnect

disconnect: (reconnect?: boolean) => void;

Disconnect from Redis.
This method closes the connection immediately, and may lose some pending replies that haven't written to client. If you want to wait for the pending replies, use Redis#quit instead.

method duplicate

duplicate: (override?: Partial<RedisOptions>) => Redis;

Create a new instance with the same options as the current one.

Example 1

var redis = new Redis(6380);
var anotherRedis = redis.duplicate();

method end

end: () => void;

Disconnect from Redis.
Deprecated

method handleReconnection

handleReconnection: (err: Error, item: CommandItem) => void;

method hscanBufferStream

hscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method hscanStream

hscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method monitor

monitor: (callback?: Callback<Redis>) => Promise<Redis>;

Listen for all requests received by the server in real time.

This command will create a new connection to Redis and send a MONITOR command via the new connection in order to avoid disturbing the current connection.

Parameter callback

The callback function. If omit, a promise will be returned.

Example 1

var redis = new Redis();
redis.monitor(function (err, monitor) {
  // Entering monitoring mode.
  monitor.on('monitor', function (time, args, source, database) {
    console.log(time + ": " + util.inspect(args));
  });
});

// supports promise as well as other commands
redis.monitor().then(function (monitor) {
  monitor.on('monitor', function (time, args, source, database) {
    console.log(time + ": " + util.inspect(args));
  });
});

method recoverFromFatalError

recoverFromFatalError: (
    _commandError: Error,
    err: Error,
    options: FlushQueueOptions
) => void;

method scanBufferStream

scanBufferStream: (options?: ScanStreamOptions) => ScanStream;

method scanStream

scanStream: (options?: ScanStreamOptions) => ScanStream;

method sendCommand

sendCommand: (command: Command, stream?: WriteableStream) => unknown;

Send a command to Redis
This method is used internally and in most cases you should not use it directly. If you need to send a command that is not supported by the library, you can use the call method:
const redis = new Redis(); redis.call('set', 'foo', 'bar'); // or redis.call(['set', 'foo', 'bar']);

method silentEmit

silentEmit: (eventName: string, arg?: unknown) => boolean;

Emit only when there's at least one listener.

method sscanBufferStream

sscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method sscanStream

sscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanBufferStream

zscanBufferStream: (key: string, options?: ScanStreamOptions) => ScanStream;

method zscanStream

zscanStream: (key: string, options?: ScanStreamOptions) => ScanStream;

class ScanStream

class ScanStream extends Readable {}

Convenient class to convert the process of scanning keys to a readable stream.

constructor

constructor(opt: Options);

method close

close: () => void;

class SentinelConnector

class SentinelConnector extends AbstractConnector {}

constructor

constructor(options: SentinelConnectionOptions);

property emitter

emitter: any;

property options

protected options: SentinelConnectionOptions;

property sentinelIterator

protected sentinelIterator: SentinelIterator;

method check

check: (info: { role?: string }) => boolean;

method connect

connect: (eventEmitter: ErrorEmitter) => Promise<NetStream>;

method disconnect

disconnect: () => void;

class SentinelIterator

class SentinelIterator implements Iterator<Partial<SentinelAddress>> {}

constructor

constructor(sentinels: Partial<SentinelAddress>[]);

method add

add: (sentinel: SentinelAddress) => boolean;

method next

next: () => { done: boolean; value: Partial<SentinelAddress> };

method reset

reset: (moveCurrentEndpointToFirst: boolean) => void;

method toString

toString: () => string;

Interfaces

interface ChainableCommander

interface ChainableCommander
    extends RedisCommander<{
        type: 'pipeline';
    }> {}

property length

length: number;

interface Cluster

interface Cluster extends EventEmitter {}

interface Cluster

interface Cluster extends Transaction {}

interface ClusterOptions

interface ClusterOptions extends CommanderOptions {}

Options for Cluster constructor

property autoPipeliningIgnoredCommands

autoPipeliningIgnoredCommands?: string[];

See Redis class.
[]

property clusterRetryStrategy

clusterRetryStrategy?: (times: number, reason?: Error) => number | void | null;

See "Quick Start" section.
(times) => Math.min(100 + times * 2, 2000)

property dnsLookup

dnsLookup?: DNSLookupFunction;

Hostnames will be resolved to IP addresses via this function. This is needed when the addresses of startup nodes are hostnames instead of IPs.
You may provide a custom lookup function when you want to customize the cache behavior of the default function.
require('dns').lookup

property enableAutoPipelining

enableAutoPipelining?: boolean;

See Redis class.
false

property enableOfflineQueue

enableOfflineQueue?: boolean;

See Redis class.
true

property enableReadyCheck

enableReadyCheck?: boolean;

When enabled, ioredis only emits "ready" event when CLUSTER INFO command reporting the cluster is ready for handling commands.
true

property lazyConnect

lazyConnect?: boolean;

By default, When a new Cluster instance is created, it will connect to the Redis cluster automatically. If you want to keep the instance disconnected until the first command is called, set this option to true.
false

property maxRedirections

maxRedirections?: number;

When a MOVED or ASK error is received, client will redirect the command to another node. This option limits the max redirections allowed to send a command.
16

property natMap

natMap?: NatMap;

property redisOptions

redisOptions?: Omit<
    RedisOptions,
    | 'port'
    | 'host'
    | 'path'
    | 'sentinels'
    | 'retryStrategy'
    | 'enableOfflineQueue'
    | 'readOnly'
>;

Passed to the constructor of Redis
null

property resolveSrv

resolveSrv?: DNSResolveSrvFunction;

SRV records will be resolved via this function.
You may provide a custom resolveSrv function when you want to customize the cache behavior of the default function.
require('dns').resolveSrv

property retryDelayOnClusterDown

retryDelayOnClusterDown?: number;

When a CLUSTERDOWN error is received, client will retry if retryDelayOnClusterDown is valid delay time (in ms).
100

property retryDelayOnFailover

retryDelayOnFailover?: number;

When an error is received when sending a command (e.g. "Connection is closed." when the target Redis node is down), client will retry if retryDelayOnFailover is valid delay time (in ms).
100

property retryDelayOnMoved

retryDelayOnMoved?: number;

By default, this value is 0, which means when a MOVED error is received, the client will resend the command instantly to the node returned together with the MOVED error. However, sometimes it takes time for a cluster to become state stabilized after a failover, so adding a delay before resending can prevent a ping pong effect.
0

property retryDelayOnTryAgain

retryDelayOnTryAgain?: number;

When a TRYAGAIN error is received, client will retry if retryDelayOnTryAgain is valid delay time (in ms).
100

property scaleReads

scaleReads?: NodeRole | Function;

Scale reads to the node with the specified role.
"master"

property scripts

scripts?: Record<
    string,
    {
        lua: string;
        numberOfKeys?: number;
        readOnly?: boolean;
    }
>;

Custom LUA commands

property slotsRefreshInterval

slotsRefreshInterval?: number;

The milliseconds between every automatic slots refresh.
5000

property slotsRefreshTimeout

slotsRefreshTimeout?: number;

The milliseconds before a timeout occurs while refreshing slots from the cluster.
1000

property useSRVRecords

useSRVRecords?: boolean;

Discover nodes using SRV records
false

interface CommonRedisOptions

interface CommonRedisOptions extends CommanderOptions {}

property autoPipeliningIgnoredCommands

autoPipeliningIgnoredCommands?: string[];

[]

property autoResendUnfulfilledCommands

autoResendUnfulfilledCommands?: boolean;

Whether or not to resend unfulfilled commands on reconnect. Unfulfilled commands are most likely to be blocking commands such as brpop or blpop. true

property autoResubscribe

autoResubscribe?: boolean;

When the client reconnects, channels subscribed in the previous connection will be resubscribed automatically if autoResubscribe is true. true

property commandQueue

commandQueue?: boolean;

property commandTimeout

commandTimeout?: number;

If a command does not return a reply within a set number of milliseconds, a "Command timed out" error will be thrown.

property connectionName

connectionName?: string;

Set the name of the connection to make it easier to identity the connection in client list. https://redis.io/commands/client-setname

property Connector

Connector?: ConnectorConstructor;

property connectTimeout

connectTimeout?: number;

How long the client will wait before killing a socket due to inactivity during initial connection. 10000

property db

db?: number;

Database index to use.
0

property enableAutoPipelining

enableAutoPipelining?: boolean;

false

property enableOfflineQueue

enableOfflineQueue?: boolean;

By default, if the connection to Redis server has not been established, commands are added to a queue and are executed once the connection is "ready" (when enableReadyCheck is true, "ready" means the Redis server has loaded the database from disk, otherwise means the connection to the Redis server has been established). If this option is false, when execute the command when the connection isn't ready, an error will be returned.
true

property enableReadyCheck

enableReadyCheck?: boolean;

The client will sent an INFO command to check whether the server is still loading data from the disk ( which happens when the server is just launched) when the connection is established, and only wait until the loading process is finished before emitting the ready event.
true

property keepAlive

keepAlive?: number;

Enable/disable keep-alive functionality. https://nodejs.org/api/net.html#socketsetkeepaliveenable-initialdelay 0

property lazyConnect

lazyConnect?: boolean;

When a Redis instance is initialized, a connection to the server is immediately established. Set this to true will delay the connection to the server until the first command is sent or redis.connect() is called explicitly.
false

property maxLoadingRetryTime

maxLoadingRetryTime?: number;

10000

property maxRetriesPerRequest

maxRetriesPerRequest?: number | null;

The commands that don't get a reply due to the connection to the server is lost are put into a queue and will be resent on reconnect (if allowed by the retryStrategy option). This option is used to configure how many reconnection attempts should be allowed before the queue is flushed with a MaxRetriesPerRequestError error. Set this options to null instead of a number to let commands wait forever until the connection is alive again.
20

property monitor

monitor?: boolean;

This option is used internally when you call redis.monitor() to tell Redis to enter the monitor mode when the connection is established.
false

property noDelay

noDelay?: boolean;

Enable/disable the use of Nagle's algorithm. https://nodejs.org/api/net.html#socketsetnodelaynodelay true

property offlineQueue

offlineQueue?: boolean;

property password

password?: string;

If set, client will send AUTH command with the value of this option when connected.

property readOnly

readOnly?: boolean;

false

property reconnectOnError

reconnectOnError?: ReconnectOnError | null;

Whether or not to reconnect on certain Redis errors. This options by default is null, which means it should never reconnect on Redis errors. You can pass a function that accepts an Redis error, and returns: - true or 1 to trigger a reconnection. - false or 0 to not reconnect. - 2 to reconnect and resend the failed command (who triggered the error) after reconnection.
Example 1
const redis = new Redis({ reconnectOnError(err) { const targetError = "READONLY"; if (err.message.includes(targetError)) { // Only reconnect when the error contains "READONLY" return true; // or `return 1;` } }, });
null

property retryStrategy

retryStrategy?: (times: number) => number | void | null;

property scripts

scripts?: Record<
    string,
    {
        lua: string;
        numberOfKeys?: number;
        readOnly?: boolean;
    }
>;

undefined

property socketTimeout

socketTimeout?: number;

If the socket does not receive data within a set number of milliseconds: 1. the socket is considered "dead" and will be destroyed 2. the client will reject any running commands (altought they might have been processed by the server) 3. the reconnect strategy will kick in (depending on the configuration)

property stringNumbers

stringNumbers?: boolean;

When enabled, numbers returned by Redis will be converted to JavaScript strings instead of numbers. This is necessary if you want to handle big numbers (above Number.MAX_SAFE_INTEGER === 2^53). false

property username

username?: string;

If set, client will send AUTH command with the value of this option as the first argument when connected. This is supported since Redis 6.

interface NatMap

interface NatMap {}

index signature

[key: string]: {
    host: string;
    port: number;
};

interface Pipeline

interface Pipeline {}

property length

length: number;

interface Redis

interface Redis extends EventEmitter {}

method on

on: {
    (event: 'message', cb: (channel: string, message: string) => void): this;
    (
        event: 'messageBuffer',
        cb: (channel: Buffer, message: Buffer) => void
    ): this;
    (
        event: 'pmessage',
        cb: (pattern: string, channel: string, message: string) => void
    ): this;
    (
        event: 'pmessageBuffer',
        cb: (pattern: string, channel: Buffer, message: Buffer) => void
    ): this;
    (event: 'error', cb: (error: Error) => void): this;
    (event: RedisStatus, cb: () => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

method once

once: {
    (event: 'message', cb: (channel: string, message: string) => void): this;
    (
        event: 'messageBuffer',
        cb: (channel: Buffer, message: Buffer) => void
    ): this;
    (
        event: 'pmessage',
        cb: (pattern: string, channel: string, message: string) => void
    ): this;
    (
        event: 'pmessageBuffer',
        cb: (pattern: string, channel: Buffer, message: Buffer) => void
    ): this;
    (event: 'error', cb: (error: Error) => void): this;
    (event: RedisStatus, cb: () => void): this;
    (event: string | symbol, listener: (...args: any[]) => void): this;
};

interface Redis

interface Redis extends Transaction {}

interface RedisCommander

interface RedisCommander<
    Context extends ClientContext = {
        type: 'default';
    }
> {}

method ["restore-asking"]

['restore-asking']: {
    (
        key: RedisKey,
        ttl: number | string,
        serializedValue: string | Buffer | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, 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

method acl

acl: {
    (subcommand: 'CAT', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'CAT', categoryname: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'DELUSER',
            ...usernames: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (subcommand: 'DELUSER', ...usernames: any[]): Result<number, Context>;
    (
        subcommand: 'DRYRUN',
        username: any,
        command: any,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        ...args: [
            subcommand: 'DRYRUN',
            username: any,
            command: any,
            ...args: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (subcommand: 'DRYRUN', username: any, command: any, ...args: any[]): Result<
        string,
        Context
    >;
    (subcommand: 'GENPASS', callback?: Callback<string>): Result<
        string,
        Context
    >;
    (
        subcommand: 'GENPASS',
        bits: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        subcommand: 'GETUSER',
        username: any,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'LIST', callback?: Callback<string[]>): Result<
        string[],
        Context
    >;
    (subcommand: 'LOAD', callback?: Callback<'OK'>): Result<'OK', Context>;
    (subcommand: 'LOG', callback?: Callback<unknown>): Result<unknown, Context>;
    (
        subcommand: 'LOG',
        count: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (subcommand: 'LOG', reset: 'RESET', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'SAVE', callback?: Callback<'OK'>): Result<'OK', Context>;
    (subcommand: 'SETUSER', username: any, callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        ...args: [
            subcommand: 'SETUSER',
            username: any,
            ...rules: any[],
            callback: Callback<'OK'>
        ]
    ): Result<'OK', Context>;
    (subcommand: 'SETUSER', username: any, ...rules: any[]): Result<
        'OK',
        Context
    >;
    (subcommand: 'USERS', callback?: Callback<string[]>): Result<
        string[],
        Context
    >;
    (subcommand: 'WHOAMI', callback?: Callback<string>): Result<string, 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
Remove the specified ACL users and the associated rules - _group_: server - _complexity_: O(1) amortized time considering the typical user. - _since_: 6.0.0
Returns whether the user can execute the given command without executing the command. - _group_: server - _complexity_: O(1). - _since_: 7.0.0
Generate a pseudorandom secure password to use for ACL users - _group_: server - _complexity_: O(1) - _since_: 6.0.0
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
Show helpful text about the different subcommands - _group_: server - _complexity_: O(1) - _since_: 6.0.0
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
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
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
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
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
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
Return the name of the user associated to the current connection - _group_: server - _complexity_: O(1) - _since_: 6.0.0

method aclBuffer

aclBuffer: {
    (
        subcommand: 'DRYRUN',
        username: string | Buffer,
        command: string | Buffer,
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        ...args: [
            subcommand: 'DRYRUN',
            username: any,
            command: any,
            ...args: any[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (subcommand: 'DRYRUN', username: any, command: any, ...args: any[]): Result<
        Buffer,
        Context
    >;
    (subcommand: 'GENPASS', callback?: Callback<Buffer>): Result<
        Buffer,
        Context
    >;
    (
        subcommand: 'GENPASS',
        bits: string | number,
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        subcommand: 'GETUSER',
        username: any,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (subcommand: 'LIST', callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
    (subcommand: 'USERS', callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
    (subcommand: 'WHOAMI', callback?: Callback<Buffer>): Result<Buffer, Context>;
};

method append

append: (
    key: RedisKey,
    value: string | Buffer | number,
    callback?: Callback<number>
) => Result<number, 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

method asking

asking: (callback?: Callback<'OK'>) => Result<'OK', Context>;

Sent by cluster clients after an -ASK redirect - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0

method auth

auth: {
    (password: string | Buffer, callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (username: any, password: any, 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

method bgrewriteaof

bgrewriteaof: (callback?: Callback<string>) => Result<string, Context>;

Asynchronously rewrite the append-only file - _group_: server - _complexity_: O(1) - _since_: 1.0.0

method bgrewriteaofBuffer

bgrewriteaofBuffer: (callback?: Callback<Buffer>) => Result<Buffer, Context>;

method bgsave

bgsave: {
    (callback?: Callback<'OK'>): Result<'OK', Context>;
    (schedule: 'SCHEDULE', callback?: Callback<'OK'>): Result<'OK', Context>;
};

Asynchronously save the dataset to disk - _group_: server - _complexity_: O(1) - _since_: 1.0.0

method bitcount

bitcount: {
    (key: RedisKey, callback?: Callback<number>): Result<number, Context>;
    (
        key: any,
        start: string | number,
        end: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        start: string | number,
        end: string | number,
        byte: 'BYTE',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        start: string | number,
        end: string | number,
        bit: 'BIT',
        callback?: Callback<number>
    ): Result<number, Context>;
};

Count set bits in a string - _group_: bitmap - _complexity_: O(N) - _since_: 2.6.0

method bitfield

bitfield: {
    (
        key: RedisKey,
        encodingOffsetToken: 'GET',
        encoding: string | Buffer,
        offset: number | string,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        encodingOffsetValueToken: 'SET',
        encoding: any,
        offset: string | number,
        value: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        encodingOffsetIncrementToken: 'INCRBY',
        encoding: any,
        offset: string | number,
        increment: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        overflow: 'OVERFLOW',
        wrap: 'WRAP',
        encodingOffsetValueToken: 'SET',
        encoding: any,
        offset: string | number,
        value: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        overflow: 'OVERFLOW',
        wrap: 'WRAP',
        encodingOffsetIncrementToken: 'INCRBY',
        encoding: any,
        offset: string | number,
        increment: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        overflow: 'OVERFLOW',
        sat: 'SAT',
        encodingOffsetValueToken: 'SET',
        encoding: any,
        offset: string | number,
        value: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        overflow: 'OVERFLOW',
        sat: 'SAT',
        encodingOffsetIncrementToken: 'INCRBY',
        encoding: any,
        offset: string | number,
        increment: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        overflow: 'OVERFLOW',
        fail: 'FAIL',
        encodingOffsetValueToken: 'SET',
        encoding: any,
        offset: string | number,
        value: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        overflow: 'OVERFLOW',
        fail: 'FAIL',
        encodingOffsetIncrementToken: 'INCRBY',
        encoding: any,
        offset: string | number,
        increment: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
};

Perform arbitrary bitfield integer operations on strings - _group_: bitmap - _complexity_: O(1) for each subcommand specified - _since_: 3.2.0

method bitfield_ro

bitfield_ro: {
    (
        ...args: [
            key: RedisKey,
            encodingOffsetToken: 'GET',
            ...encodingOffsets: (string | Buffer | number)[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (key: any, encodingOffsetToken: 'GET', ...encodingOffsets: any[]): 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

method bitop

bitop: {
    (
        ...args: [
            operation: string | Buffer,
            destkey: RedisKey,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        operation: any,
        destkey: any,
        keys: any[],
        callback: Callback<number>
    ): Result<number, Context>;
    (operation: any, destkey: any, ...keys: any[]): Result<number, Context>;
    (operation: any, destkey: any, keys: any[]): Result<number, Context>;
};

Perform bitwise operations between strings - _group_: bitmap - _complexity_: O(N) - _since_: 2.6.0

method bitpos

bitpos: {
    (key: RedisKey, bit: number | string, callback?: Callback<number>): Result<
        number,
        Context
    >;
    (
        key: any,
        bit: string | number,
        start: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        bit: string | number,
        start: string | number,
        end: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        bit: string | number,
        start: string | number,
        end: string | number,
        byte: 'BYTE',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        bit: string | number,
        start: string | number,
        end: string | number,
        bit1: 'BIT',
        callback?: Callback<number>
    ): Result<number, Context>;
};

Find first bit set or clear in a string - _group_: bitmap - _complexity_: O(N) - _since_: 2.8.7

method blmove

blmove: {
    (
        source: RedisKey,
        destination: RedisKey,
        left: 'LEFT',
        left1: 'LEFT',
        timeout: number | string,
        callback?: Callback<string | null>
    ): Result<string | null, Context>;
    (
        source: any,
        destination: any,
        left: 'LEFT',
        right: 'RIGHT',
        timeout: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        left: 'LEFT',
        timeout: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        right1: 'RIGHT',
        timeout: string | number,
        callback?: Callback<string>
    ): Result<string, 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

method blmoveBuffer

blmoveBuffer: {
    (
        source: RedisKey,
        destination: RedisKey,
        left: 'LEFT',
        left1: 'LEFT',
        timeout: number | string,
        callback?: Callback<Buffer | null>
    ): Result<Buffer | null, Context>;
    (
        source: any,
        destination: any,
        left: 'LEFT',
        right: 'RIGHT',
        timeout: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        left: 'LEFT',
        timeout: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        right1: 'RIGHT',
        timeout: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
};

method blmpop

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>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT'
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT'
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: string, members: string[]]>
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            callback: Callback<[key: string, members: string[]]>
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT'
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT'
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: string, members: string[]]>
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: string, members: string[]], 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

method blmpopBuffer

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>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT'
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT'
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: Buffer, members: Buffer[]]>
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            callback: Callback<[key: Buffer, members: Buffer[]]>
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT'
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT'
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: Buffer, members: Buffer[]]>
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: Buffer, members: Buffer[]], Context>;
};

method blpop

blpop: {
    (
        ...args: [
            ...keys: RedisKey[],
            timeout: number | string,
            callback: Callback<[string, string] | null>
        ]
    ): Result<[string, string] | null, Context>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[string, string]>
    ): Result<[string, string], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [string, string],
        Context
    >;
    (keys: any[], timeout: string | number): Result<[string, string], 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

method blpopBuffer

blpopBuffer: {
    (
        ...args: [
            ...keys: RedisKey[],
            timeout: number | string,
            callback: Callback<[Buffer, Buffer] | null>
        ]
    ): Result<[Buffer, Buffer] | null, Context>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[Buffer, Buffer]>
    ): Result<[Buffer, Buffer], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [Buffer, Buffer],
        Context
    >;
    (keys: any[], timeout: string | number): Result<[Buffer, Buffer], Context>;
};

method brpop

brpop: {
    (
        ...args: [
            ...keys: RedisKey[],
            timeout: number | string,
            callback: Callback<[string, string] | null>
        ]
    ): Result<[string, string] | null, Context>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[string, string]>
    ): Result<[string, string], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [string, string],
        Context
    >;
    (keys: any[], timeout: string | number): Result<[string, string], 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

method brpopBuffer

brpopBuffer: {
    (
        ...args: [
            ...keys: RedisKey[],
            timeout: number | string,
            callback: Callback<[Buffer, Buffer] | null>
        ]
    ): Result<[Buffer, Buffer] | null, Context>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[Buffer, Buffer]>
    ): Result<[Buffer, Buffer], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [Buffer, Buffer],
        Context
    >;
    (keys: any[], timeout: string | number): Result<[Buffer, Buffer], Context>;
};

method brpoplpush

brpoplpush: (
    source: RedisKey,
    destination: RedisKey,
    timeout: number | string,
    callback?: Callback<string | null>
) => Result<string | 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

method brpoplpushBuffer

brpoplpushBuffer: (
    source: RedisKey,
    destination: RedisKey,
    timeout: number | string,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method bzmpop

bzmpop: {
    (
        ...args: [
            timeout: number | string,
            numkeys: number | string,
            ...keys: RedisKey[],
            min: 'MIN',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        min: 'MIN',
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            min: 'MIN'
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        min: 'MIN'
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            min: 'MIN',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        min: 'MIN',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            min: 'MIN',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        min: 'MIN',
        countToken: 'COUNT',
        count: string | number
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        max: 'MAX',
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX'
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        max: 'MAX'
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        max: 'MAX',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            timeout: string | number,
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<unknown, Context>;
    (
        timeout: string | number,
        numkeys: string | number,
        keys: any[],
        max: 'MAX',
        countToken: 'COUNT',
        count: string | number
    ): Result<unknown, 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

method bzpopmax

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>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[key: string, member: string, score: string]>
    ): Result<[key: string, member: string, score: string], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [key: string, member: string, score: string],
        Context
    >;
    (keys: any[], timeout: string | number): Result<
        [key: string, member: string, score: string],
        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

method bzpopmaxBuffer

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>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>
    ): Result<[key: Buffer, member: Buffer, score: Buffer], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [key: Buffer, member: Buffer, score: Buffer],
        Context
    >;
    (keys: any[], timeout: string | number): Result<
        [key: Buffer, member: Buffer, score: Buffer],
        Context
    >;
};

method bzpopmin

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>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[key: string, member: string, score: string]>
    ): Result<[key: string, member: string, score: string], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [key: string, member: string, score: string],
        Context
    >;
    (keys: any[], timeout: string | number): Result<
        [key: string, member: string, score: string],
        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

method bzpopminBuffer

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>;
    (
        keys: any[],
        timeout: string | number,
        callback: Callback<[key: Buffer, member: Buffer, score: Buffer]>
    ): Result<[key: Buffer, member: Buffer, score: Buffer], Context>;
    (...args: [...keys: any[], timeout: string | number]): Result<
        [key: Buffer, member: Buffer, score: Buffer],
        Context
    >;
    (keys: any[], timeout: string | number): Result<
        [key: Buffer, member: Buffer, score: Buffer],
        Context
    >;
};

method call

call: {
    (command: string, callback?: Callback<unknown>): Result<unknown, Context>;
    (command: string, args: any[], callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [command: string, ...args: any[], callback: Callback<unknown>]
    ): Result<unknown, Context>;
    (command: string, ...args: any[]): Result<unknown, Context>;
};

Call arbitrary commands.
redis.call('set', 'foo', 'bar') is the same as redis.set('foo', 'bar'), so the only case you need to use this method is when the command is not supported by ioredis.
redis.call('set', 'foo', 'bar'); redis.call('get', 'foo', (err, value) => { // value === 'bar' });

method callBuffer

callBuffer: {
    (command: string, callback?: Callback<unknown>): Result<unknown, Context>;
    (command: string, args: any[], callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [command: string, ...args: any[], callback: Callback<unknown>]
    ): Result<unknown, Context>;
    (command: string, ...args: any[]): Result<unknown, Context>;
};

method client

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

Instruct the server about tracking or not keys in the next request - _group_: connection - _complexity_: O(1) - _since_: 6.0.0
Get the current connection name - _group_: connection - _complexity_: O(1) - _since_: 2.6.9
Get tracking notifications redirection client ID if any - _group_: connection - _complexity_: O(1) - _since_: 6.0.0
Show helpful text about the different subcommands - _group_: connection - _complexity_: O(1) - _since_: 5.0.0
Returns the client ID for the current connection - _group_: connection - _complexity_: O(1) - _since_: 5.0.0
Returns information about the current client connection. - _group_: connection - _complexity_: O(1) - _since_: 6.2.0
Kill the connection of a client - _group_: connection - _complexity_: O(N) where N is the number of client connections - _since_: 2.4.0
Get the list of client connections - _group_: connection - _complexity_: O(N) where N is the number of client connections - _since_: 2.4.0
Set client eviction mode for the current connection - _group_: connection - _complexity_: O(1) - _since_: 7.0.0
Stop processing commands from clients for some time - _group_: connection - _complexity_: O(1) - _since_: 2.9.50
Instruct the server whether to reply to commands - _group_: connection - _complexity_: O(1) - _since_: 3.2.0
Set the current connection name - _group_: connection - _complexity_: O(1) - _since_: 2.6.9
Enable or disable server assisted client side caching support - _group_: connection - _complexity_: O(1). Some options may introduce additional complexity. - _since_: 6.0.0
Return information about server assisted client side caching for the current connection - _group_: connection - _complexity_: O(1) - _since_: 6.2.0
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
Resume processing of clients that were paused - _group_: connection - _complexity_: O(N) Where N is the number of paused clients - _since_: 6.2.0

method clientBuffer

clientBuffer: {
    (subcommand: 'GETNAME', callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (subcommand: 'INFO', callback?: Callback<Buffer>): Result<Buffer, Context>;
    (subcommand: 'TRACKINGINFO', callback?: Callback<Buffer>): Result<
        Buffer,
        Context
    >;
};

method cluster

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

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
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
Advance the cluster config epoch - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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
Return the number of local keys in the specified hash slot - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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
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
Forces a replica to perform a manual failover of its master. - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
Delete a node's own slots information - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
Remove a node from the nodes table - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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
Show helpful text about the different subcommands - _group_: cluster - _complexity_: O(1) - _since_: 5.0.0
Provides info about Redis Cluster node state - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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
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
Force a node cluster to handshake with another node - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
Return the node id - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
Get Cluster config for the node - _group_: cluster - _complexity_: O(N) where N is the total number of Cluster nodes - _since_: 3.0.0
List replica nodes of the specified master node - _group_: cluster - _complexity_: O(1) - _since_: 5.0.0
Reconfigure a node as a replica of the specified master node - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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
Forces the node to save cluster state on disk - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
Set the configuration epoch in a new node - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
Bind a hash slot to a specific node - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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
List replica nodes of the specified master node - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0
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

method command

command: {
    (subcommand: 'COUNT', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'DOCS', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        ...args: [
            subcommand: 'DOCS',
            ...commandNames: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (subcommand: 'DOCS', ...commandNames: any[]): Result<unknown[], Context>;
    (subcommand: 'GETKEYS', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'GETKEYSANDFLAGS', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'HELP', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'INFO', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        ...args: [
            subcommand: 'INFO',
            ...commandNames: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (subcommand: 'INFO', ...commandNames: any[]): Result<unknown[], Context>;
    (subcommand: 'LIST', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        subcommand: 'LIST',
        filterby: 'FILTERBY',
        moduleNameToken: 'MODULE',
        moduleName: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        subcommand: 'LIST',
        filterby: 'FILTERBY',
        categoryToken: 'ACLCAT',
        category: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        subcommand: 'LIST',
        filterby: 'FILTERBY',
        patternToken: 'PATTERN',
        pattern: string,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
};

Get total number of Redis commands - _group_: server - _complexity_: O(1) - _since_: 2.8.13
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
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
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
Show helpful text about the different subcommands - _group_: server - _complexity_: O(1) - _since_: 5.0.0
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
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

method config

config: {
    (
        ...args: [
            subcommand: 'GET',
            ...parameters: (string | Buffer)[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: 'GET', ...parameters: any[]): Result<unknown, Context>;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'RESETSTAT', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'REWRITE', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'SET',
            ...parameterValues: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: 'SET', ...parameterValues: any[]): 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
Show helpful text about the different subcommands - _group_: server - _complexity_: O(1) - _since_: 5.0.0
Reset the stats returned by INFO - _group_: server - _complexity_: O(1) - _since_: 2.0.0
Rewrite the configuration file with the in memory configuration - _group_: server - _complexity_: O(1) - _since_: 2.8.0
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

method copy

copy: {
    (
        source: RedisKey,
        destination: RedisKey,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        source: any,
        destination: any,
        replace: 'REPLACE',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        source: any,
        destination: any,
        destinationDbToken: 'DB',
        destinationDb: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        source: any,
        destination: any,
        destinationDbToken: 'DB',
        destinationDb: string | number,
        replace: 'REPLACE',
        callback?: Callback<number>
    ): Result<number, 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

method dbsize

dbsize: (callback?: Callback<number>) => Result<number, Context>;

Return the number of keys in the selected database - _group_: server - _complexity_: O(1) - _since_: 1.0.0

method debug

debug: {
    (subcommand: string, callback?: Callback<unknown>): Result<unknown, Context>;
    (
        ...args: [
            subcommand: string,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: string, ...args: any[]): Result<unknown, Context>;
};

A container for debugging commands - _group_: server - _complexity_: Depends on subcommand. - _since_: 1.0.0

method decr

decr: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Decrement the integer value of a key by one - _group_: string - _complexity_: O(1) - _since_: 1.0.0

method decrby

decrby: (
    key: RedisKey,
    decrement: number | string,
    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

method del

del: {
    (...args: [...keys: RedisKey[], callback: Callback<number>]): Result<
        number,
        Context
    >;
    (keys: any[], callback: Callback<number>): Result<number, Context>;
    (...args: any[]): Result<number, Context>;
    (keys: any[]): 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

method discard

discard: (callback?: Callback<'OK'>) => Result<'OK', Context>;

Discard all commands issued after MULTI - _group_: transactions - _complexity_: O(N), when N is the number of queued commands - _since_: 2.0.0

method dump

dump: (key: RedisKey, callback?: Callback<string>) => Result<string, 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

method dumpBuffer

dumpBuffer: (
    key: RedisKey,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method echo

echo: (
    message: string | Buffer,
    callback?: Callback<string>
) => Result<string, Context>;

Echo the given string - _group_: connection - _complexity_: O(1) - _since_: 1.0.0

method echoBuffer

echoBuffer: (
    message: string | Buffer,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method eval

eval: {
    (
        script: string | Buffer,
        numkeys: number | string,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            script: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (script: any, numkeys: string | number, ...args: any[]): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            script: any,
            numkeys: string | number,
            ...keys: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        script: any,
        numkeys: string | number,
        keys: any[],
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (script: any, numkeys: string | number, ...keys: any[]): Result<
        unknown,
        Context
    >;
    (script: any, numkeys: string | number, keys: any[]): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            script: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (script: any, numkeys: string | number, ...args: any[]): Result<
        unknown,
        Context
    >;
};

Execute a Lua script server side - _group_: scripting - _complexity_: Depends on the script that is executed. - _since_: 2.6.0

method eval_ro

eval_ro: {
    (
        ...args: [
            script: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (script: any, numkeys: string | number, ...args: any[]): 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

method evalsha

evalsha: {
    (
        sha1: string | Buffer,
        numkeys: number | string,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            sha1: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (sha1: any, numkeys: string | number, ...args: any[]): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            sha1: any,
            numkeys: string | number,
            ...keys: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        sha1: any,
        numkeys: string | number,
        keys: any[],
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (sha1: any, numkeys: string | number, ...keys: any[]): Result<
        unknown,
        Context
    >;
    (sha1: any, numkeys: string | number, keys: any[]): Result<unknown, Context>;
    (
        ...args: [
            sha1: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (sha1: any, numkeys: string | number, ...args: any[]): Result<
        unknown,
        Context
    >;
};

Execute a Lua script server side - _group_: scripting - _complexity_: Depends on the script that is executed. - _since_: 2.6.0

method evalsha_ro

evalsha_ro: {
    (
        ...args: [
            sha1: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (sha1: any, numkeys: string | number, ...args: any[]): 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

method exec

exec: (
    callback?: Callback<[error: Error | null, result: unknown][] | null>
) => Promise<[error: Error | null, result: unknown][] | null>;

Execute all commands issued after MULTI - _group_: transactions - _complexity_: Depends on commands in the transaction - _since_: 1.2.0

method exists

exists: {
    (...args: [...keys: RedisKey[], callback: Callback<number>]): Result<
        number,
        Context
    >;
    (keys: any[], callback: Callback<number>): Result<number, Context>;
    (...args: any[]): Result<number, Context>;
    (keys: any[]): Result<number, Context>;
};

Determine if a key exists - _group_: generic - _complexity_: O(N) where N is the number of keys to check. - _since_: 1.0.0

method expire

expire: {
    (
        key: RedisKey,
        seconds: number | string,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        seconds: string | number,
        nx: 'NX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        seconds: string | number,
        xx: 'XX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        seconds: string | number,
        gt: 'GT',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        seconds: string | number,
        lt: 'LT',
        callback?: Callback<number>
    ): Result<number, Context>;
};

Set a key's time to live in seconds - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method expireat

expireat: {
    (
        key: RedisKey,
        unixTimeSeconds: number | string,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeSeconds: string | number,
        nx: 'NX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeSeconds: string | number,
        xx: 'XX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeSeconds: string | number,
        gt: 'GT',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeSeconds: string | number,
        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

method expiretime

expiretime: (
    key: RedisKey,
    callback?: Callback<number>
) => Result<number, Context>;

Get the expiration Unix timestamp for a key - _group_: generic - _complexity_: O(1) - _since_: 7.0.0

method failover

failover: {
    (callback?: Callback<'OK'>): Result<'OK', Context>;
    (
        millisecondsToken: 'TIMEOUT',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
    (
        abort: 'ABORT',
        millisecondsToken: 'TIMEOUT',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        millisecondsToken: 'TIMEOUT',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        abort: 'ABORT',
        millisecondsToken: 'TIMEOUT',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        force: 'FORCE',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        force: 'FORCE',
        millisecondsToken: 'TIMEOUT',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        force: 'FORCE',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        targetToken: 'TO',
        host: any,
        port: string | number,
        force: 'FORCE',
        abort: 'ABORT',
        millisecondsToken: 'TIMEOUT',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
};

Start a coordinated failover between this server and one of its replicas. - _group_: server - _complexity_: O(1) - _since_: 6.2.0

method fcall

Invoke a function - _group_: scripting - _complexity_: Depends on the function that is executed. - _since_: 7.0.0

method fcall_ro

Invoke a read-only function - _group_: scripting - _complexity_: Depends on the function that is executed. - _since_: 7.0.0

method flushall

flushall: {
    (callback?: Callback<'OK'>): Result<'OK', Context>;
    (async: 'ASYNC', callback?: Callback<'OK'>): Result<'OK', Context>;
    (sync: 'SYNC', callback?: Callback<'OK'>): Result<'OK', 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

method flushdb

flushdb: {
    (callback?: Callback<'OK'>): Result<'OK', Context>;
    (async: 'ASYNC', callback?: Callback<'OK'>): Result<'OK', Context>;
    (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

method function

function: {
    (
        subcommand: 'DELETE',
        libraryName: string | Buffer,
        callback?: Callback<string>
    ): Result<string, Context>;
    (subcommand: 'DUMP', callback?: Callback<string>): Result<string, Context>;
    (subcommand: 'FLUSH', callback?: Callback<string>): Result<string, Context>;
    (subcommand: 'FLUSH', async: 'ASYNC', callback?: Callback<string>): Result<
        string,
        Context
    >;
    (subcommand: 'FLUSH', sync: 'SYNC', callback?: Callback<string>): Result<
        string,
        Context
    >;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'KILL', callback?: Callback<string>): Result<string, Context>;
    (subcommand: 'LIST', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        subcommand: 'LIST',
        withcode: 'WITHCODE',
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        subcommand: 'LIST',
        libraryNamePatternToken: 'LIBRARYNAME',
        libraryNamePattern: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        subcommand: 'LIST',
        libraryNamePatternToken: 'LIBRARYNAME',
        libraryNamePattern: any,
        withcode: 'WITHCODE',
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (subcommand: 'LOAD', functionCode: any, callback?: Callback<string>): Result<
        string,
        Context
    >;
    (
        subcommand: 'LOAD',
        replace: 'REPLACE',
        functionCode: any,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        flush: 'FLUSH',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        append: 'APPEND',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        replace: 'REPLACE',
        callback?: Callback<string>
    ): Result<string, Context>;
    (subcommand: 'STATS', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
};

Delete a function by name - _group_: scripting - _complexity_: O(1) - _since_: 7.0.0
Dump all functions into a serialized binary payload - _group_: scripting - _complexity_: O(N) where N is the number of functions - _since_: 7.0.0
Deleting all functions - _group_: scripting - _complexity_: O(N) where N is the number of functions deleted - _since_: 7.0.0
Show helpful text about the different subcommands - _group_: scripting - _complexity_: O(1) - _since_: 7.0.0
Kill the function currently in execution. - _group_: scripting - _complexity_: O(1) - _since_: 7.0.0
List information about all the functions - _group_: scripting - _complexity_: O(N) where N is the number of functions - _since_: 7.0.0
Create a function with the given arguments (name, code, description) - _group_: scripting - _complexity_: O(1) (considering compilation time is redundant) - _since_: 7.0.0
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
Return information about the function currently running (name, description, duration) - _group_: scripting - _complexity_: O(1) - _since_: 7.0.0

method functionBuffer

functionBuffer: {
    (
        subcommand: 'DELETE',
        libraryName: string | Buffer,
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (subcommand: 'DUMP', callback?: Callback<Buffer>): Result<Buffer, Context>;
    (subcommand: 'FLUSH', callback?: Callback<Buffer>): Result<Buffer, Context>;
    (subcommand: 'FLUSH', async: 'ASYNC', callback?: Callback<Buffer>): Result<
        Buffer,
        Context
    >;
    (subcommand: 'FLUSH', sync: 'SYNC', callback?: Callback<Buffer>): Result<
        Buffer,
        Context
    >;
    (subcommand: 'KILL', callback?: Callback<Buffer>): Result<Buffer, Context>;
    (subcommand: 'LOAD', functionCode: any, callback?: Callback<Buffer>): Result<
        Buffer,
        Context
    >;
    (
        subcommand: 'LOAD',
        replace: 'REPLACE',
        functionCode: any,
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        flush: 'FLUSH',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        append: 'APPEND',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        subcommand: 'RESTORE',
        serializedValue: any,
        replace: 'REPLACE',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
};

method geoadd

geoadd: {
    (
        ...args: [
            key: RedisKey,
            ...longitudeLatitudeMembers: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...longitudeLatitudeMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            ch: 'CH',
            ...longitudeLatitudeMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ch: 'CH', ...longitudeLatitudeMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            ...longitudeLatitudeMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', ...longitudeLatitudeMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            ch: 'CH',
            ...longitudeLatitudeMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', ch: 'CH', ...longitudeLatitudeMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            ...longitudeLatitudeMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', ...longitudeLatitudeMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            ch: 'CH',
            ...longitudeLatitudeMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', ch: 'CH', ...longitudeLatitudeMembers: any[]): Result<
        number,
        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

method geodist

geodist: {
    (
        key: RedisKey,
        member1: string | Buffer | number,
        member2: string | Buffer | number,
        callback?: Callback<string | null>
    ): Result<string | null, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        m: 'M',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        km: 'KM',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        ft: 'FT',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        mi: 'MI',
        callback?: Callback<string>
    ): Result<string, Context>;
};

Returns the distance between two members of a geospatial index - _group_: geo - _complexity_: O(log(N)) - _since_: 3.2.0

method geodistBuffer

geodistBuffer: {
    (
        key: RedisKey,
        member1: string | Buffer | number,
        member2: string | Buffer | number,
        callback?: Callback<Buffer | null>
    ): Result<Buffer | null, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        m: 'M',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        km: 'KM',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        ft: 'FT',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        member1: any,
        member2: any,
        mi: 'MI',
        callback?: Callback<any>
    ): Result<any, Context>;
};

method geohash

geohash: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (key: any, members: any[], callback: Callback<string[]>): Result<
        string[],
        Context
    >;
    (key: any, ...members: any[]): Result<string[], Context>;
    (key: any, members: any[]): Result<string[], 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

method geohashBuffer

geohashBuffer: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (key: any, members: any[], callback: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
    (key: any, ...members: any[]): Result<Buffer[], Context>;
    (key: any, members: any[]): Result<Buffer[], Context>;
};

method geopos

geopos: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<([longitude: string, latitude: string] | null)[]>
        ]
    ): Result<([longitude: string, latitude: string] | null)[], Context>;
    (
        key: any,
        members: any[],
        callback: Callback<[longitude: string, latitude: string][]>
    ): Result<[longitude: string, latitude: string][], Context>;
    (key: any, ...members: any[]): Result<
        [longitude: string, latitude: string][],
        Context
    >;
    (key: any, members: any[]): Result<
        [longitude: string, latitude: string][],
        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

method georadius

georadius: {
    (
        ...args: [
            key: any,
            longitude: string | number,
            latitude: string | number,
            radius: string | number,
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        key: any,
        longitude: string | number,
        latitude: string | number,
        radius: string | number,
        ...args: any[]
    ): Result<unknown[], 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

method georadius_ro

georadius_ro: {
    (
        ...args: [
            key: any,
            longitude: string | number,
            latitude: string | number,
            radius: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        longitude: string | number,
        latitude: string | number,
        radius: string | number,
        ...args: any[]
    ): 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

method georadiusbymember

georadiusbymember: {
    (
        ...args: [
            key: any,
            member: any,
            radius: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (key: any, member: any, radius: string | number, ...args: any[]): 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

method georadiusbymember_ro

georadiusbymember_ro: {
    (
        ...args: [
            key: any,
            member: any,
            radius: string | number,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (key: any, member: any, radius: string | number, ...args: any[]): 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

method geosearch

geosearch: {
    (...args: [key: any, ...args: any[], callback: Callback<unknown[]>]): Result<
        unknown[],
        Context
    >;
    (key: any, ...args: any[]): 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

method geosearchstore

geosearchstore: {
    (
        ...args: [
            destination: any,
            source: any,
            ...args: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (destination: any, source: any, ...args: any[]): Result<number, 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

method get

get: (
    key: RedisKey,
    callback?: Callback<string | null>
) => Result<string | null, Context>;

Get the value of a key - _group_: string - _complexity_: O(1) - _since_: 1.0.0

method getbit

getbit: (
    key: RedisKey,
    offset: number | string,
    callback?: Callback<number>
) => Result<number, Context>;

Returns the bit value at offset in the string value stored at key - _group_: bitmap - _complexity_: O(1) - _since_: 2.2.0

method getBuffer

getBuffer: (
    key: RedisKey,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method getdel

getdel: (
    key: RedisKey,
    callback?: Callback<string | null>
) => Result<string | null, Context>;

Get the value of a key and delete the key - _group_: string - _complexity_: O(1) - _since_: 6.2.0

method getdelBuffer

getdelBuffer: (
    key: RedisKey,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method getex

getex: {
    (key: RedisKey, callback?: Callback<string | null>): Result<
        string | null,
        Context
    >;
    (
        key: any,
        secondsToken: 'EX',
        seconds: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
    (key: any, persist: 'PERSIST', callback?: Callback<string>): Result<
        string,
        Context
    >;
};

Get the value of a key and optionally set its expiration - _group_: string - _complexity_: O(1) - _since_: 6.2.0

method getexBuffer

getexBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (
        key: any,
        secondsToken: 'EX',
        seconds: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        callback?: Callback<any>
    ): Result<any, Context>;
    (key: any, persist: 'PERSIST', callback?: Callback<any>): Result<
        any,
        Context
    >;
};

method getrange

getrange: (
    key: RedisKey,
    start: number | string,
    end: number | string,
    callback?: Callback<string>
) => Result<string, 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

method getrangeBuffer

getrangeBuffer: (
    key: RedisKey,
    start: number | string,
    end: number | string,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method getset

getset: (
    key: RedisKey,
    value: string | Buffer | number,
    callback?: Callback<string | null>
) => Result<string | null, Context>;

Set the string value of a key and return its old value - _group_: string - _complexity_: O(1) - _since_: 1.0.0

method getsetBuffer

getsetBuffer: (
    key: RedisKey,
    value: string | Buffer | number,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method hdel

hdel: {
    (
        ...args: [
            key: RedisKey,
            ...fields: (string | Buffer)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...fields: any[]): Result<number, 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

method hello

hello: {
    (callback?: Callback<unknown[]>): Result<unknown[], Context>;
    (protover: string | number, callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        protover: string | number,
        clientnameToken: 'SETNAME',
        clientname: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        protover: string | number,
        usernamePasswordToken: 'AUTH',
        username: any,
        password: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        protover: string | number,
        usernamePasswordToken: 'AUTH',
        username: any,
        password: any,
        clientnameToken: 'SETNAME',
        clientname: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
};

Handshake with Redis - _group_: connection - _complexity_: O(1) - _since_: 6.0.0

method hexists

hexists: (
    key: RedisKey,
    field: string | Buffer,
    callback?: Callback<number>
) => Result<number, Context>;

Determine if a hash field exists - _group_: hash - _complexity_: O(1) - _since_: 2.0.0

method hget

hget: (
    key: RedisKey,
    field: string | Buffer,
    callback?: Callback<string | null>
) => Result<string | null, Context>;

Get the value of a hash field - _group_: hash - _complexity_: O(1) - _since_: 2.0.0

method hgetall

hgetall: (
    key: RedisKey,
    callback?: Callback<Record<string, string>>
) => Result<Record<string, string>, 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

method hgetallBuffer

hgetallBuffer: (
    key: RedisKey,
    callback?: Callback<Record<string, Buffer>>
) => Result<Record<string, Buffer>, Context>;

method hgetBuffer

hgetBuffer: (
    key: RedisKey,
    field: string | Buffer,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method hincrby

hincrby: (
    key: RedisKey,
    field: string | Buffer,
    increment: number | string,
    callback?: Callback<number>
) => Result<number, Context>;

Increment the integer value of a hash field by the given number - _group_: hash - _complexity_: O(1) - _since_: 2.0.0

method hincrbyfloat

hincrbyfloat: (
    key: RedisKey,
    field: string | Buffer,
    increment: number | string,
    callback?: Callback<string>
) => Result<string, Context>;

Increment the float value of a hash field by the given amount - _group_: hash - _complexity_: O(1) - _since_: 2.6.0

method hincrbyfloatBuffer

hincrbyfloatBuffer: (
    key: RedisKey,
    field: string | Buffer,
    increment: number | string,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method hkeys

hkeys: (
    key: RedisKey,
    callback?: Callback<string[]>
) => Result<string[], 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

method hkeysBuffer

hkeysBuffer: (
    key: RedisKey,
    callback?: Callback<Buffer[]>
) => Result<Buffer[], Context>;

method hlen

hlen: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the number of fields in a hash - _group_: hash - _complexity_: O(1) - _since_: 2.0.0

method hmget

hmget: {
    (
        ...args: [
            key: RedisKey,
            ...fields: (string | Buffer)[],
            callback: Callback<(string | null)[]>
        ]
    ): Result<(string | null)[], Context>;
    (key: any, ...fields: any[]): Result<string[], 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

method hmgetBuffer

hmgetBuffer: {
    (
        ...args: [
            key: RedisKey,
            ...fields: (string | Buffer)[],
            callback: Callback<(Buffer | null)[]>
        ]
    ): Result<(Buffer | null)[], Context>;
    (key: any, ...fields: any[]): Result<any[], Context>;
};

method hmset

hmset: {
    (key: RedisKey, object: object, callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (key: any, map: Map<any, any>, callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        ...args: [key: any, ...fieldValues: any[], callback: Callback<'OK'>]
    ): Result<'OK', Context>;
    (key: any, ...fieldValues: any[]): Result<'OK', 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

method hrandfield

hrandfield: {
    (key: RedisKey, callback?: Callback<string | unknown[] | null>): Result<
        string | unknown[] | null,
        Context
    >;
    (
        key: any,
        count: string | number,
        callback?: Callback<string | unknown[]>
    ): Result<string | unknown[], Context>;
    (
        key: any,
        count: string | number,
        withvalues: 'WITHVALUES',
        callback?: Callback<string | unknown[]>
    ): Result<string | unknown[], 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

method hrandfieldBuffer

hrandfieldBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | unknown[] | null>): Result<
        Buffer | unknown[] | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<any>): Result<
        any,
        Context
    >;
    (
        key: any,
        count: string | number,
        withvalues: 'WITHVALUES',
        callback?: Callback<any>
    ): Result<any, Context>;
};

method hscan

hscan: {
    (
        key: RedisKey,
        cursor: number | string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], 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

method hscanBuffer

hscanBuffer: {
    (
        key: RedisKey,
        cursor: number | string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
};

method hset

hset: {
    (key: RedisKey, object: object, callback?: Callback<number>): Result<
        number,
        Context
    >;
    (key: any, map: Map<any, any>, callback?: Callback<number>): Result<
        number,
        Context
    >;
    (
        ...args: [key: any, ...fieldValues: any[], callback: Callback<number>]
    ): Result<number, Context>;
    (key: any, ...fieldValues: any[]): Result<number, 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

method hsetnx

hsetnx: (
    key: RedisKey,
    field: string | Buffer,
    value: string | Buffer | number,
    callback?: Callback<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

method hstrlen

hstrlen: (
    key: RedisKey,
    field: string | Buffer,
    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

method hvals

hvals: (
    key: RedisKey,
    callback?: Callback<string[]>
) => Result<string[], 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

method hvalsBuffer

hvalsBuffer: (
    key: RedisKey,
    callback?: Callback<Buffer[]>
) => Result<Buffer[], Context>;

method incr

incr: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Increment the integer value of a key by one - _group_: string - _complexity_: O(1) - _since_: 1.0.0

method incrby

incrby: (
    key: RedisKey,
    increment: number | string,
    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

method incrbyfloat

incrbyfloat: (
    key: RedisKey,
    increment: number | string,
    callback?: Callback<string>
) => Result<string, Context>;

Increment the float value of a key by the given amount - _group_: string - _complexity_: O(1) - _since_: 2.6.0

method info

info: {
    (callback?: Callback<string>): Result<string, Context>;
    (...args: [...sections: any[], callback: Callback<string>]): Result<
        string,
        Context
    >;
    (...args: any[]): Result<string, Context>;
};

Get information and statistics about the server - _group_: server - _complexity_: O(1) - _since_: 1.0.0

method keys

keys: (
    pattern: string,
    callback?: Callback<string[]>
) => 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

method keysBuffer

keysBuffer: (
    pattern: string,
    callback?: Callback<Buffer[]>
) => Result<Buffer[], Context>;

method lastsave

lastsave: (callback?: Callback<number>) => Result<number, Context>;

Get the UNIX time stamp of the last successful save to disk - _group_: server - _complexity_: O(1) - _since_: 1.0.0

method latency

latency: {
    (subcommand: 'DOCTOR', callback?: Callback<string>): Result<string, Context>;
    (subcommand: 'GRAPH', event: any, callback?: Callback<string>): Result<
        string,
        Context
    >;
    (subcommand: 'HELP', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'HISTOGRAM', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'HISTOGRAM',
            ...commands: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: 'HISTOGRAM', ...commands: any[]): Result<unknown, Context>;
    (subcommand: 'HISTORY', event: any, callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'LATEST', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'RESET', callback?: Callback<number>): Result<number, Context>;
    (
        ...args: [
            subcommand: 'RESET',
            ...events: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (subcommand: 'RESET', ...events: any[]): Result<number, Context>;
};

Return a human readable latency analysis report. - _group_: server - _complexity_: O(1) - _since_: 2.8.13
Return a latency graph for the event. - _group_: server - _complexity_: O(1) - _since_: 2.8.13
Show helpful text about the different subcommands. - _group_: server - _complexity_: O(1) - _since_: 2.8.13
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
Return timestamp-latency samples for the event. - _group_: server - _complexity_: O(1) - _since_: 2.8.13
Return the latest latency samples for all events. - _group_: server - _complexity_: O(1) - _since_: 2.8.13
Reset latency data for one or more events. - _group_: server - _complexity_: O(1) - _since_: 2.8.13

method lcs

lcs: {
    (key1: RedisKey, key2: RedisKey, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        key1: any,
        key2: any,
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        lenToken: 'MINMATCHLEN',
        len: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        lenToken: 'MINMATCHLEN',
        len: string | number,
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (key1: any, key2: any, idx: 'IDX', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        key1: any,
        key2: any,
        idx: 'IDX',
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        idx: 'IDX',
        lenToken: 'MINMATCHLEN',
        len: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        idx: 'IDX',
        lenToken: 'MINMATCHLEN',
        len: string | number,
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (key1: any, key2: any, len: 'LEN', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        lenToken: 'MINMATCHLEN',
        len1: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        lenToken: 'MINMATCHLEN',
        len1: string | number,
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        idx: 'IDX',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        idx: 'IDX',
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        idx: 'IDX',
        lenToken: 'MINMATCHLEN',
        len1: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key1: any,
        key2: any,
        len: 'LEN',
        idx: 'IDX',
        lenToken: 'MINMATCHLEN',
        len1: string | number,
        withmatchlen: 'WITHMATCHLEN',
        callback?: Callback<unknown>
    ): Result<unknown, 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

method lindex

lindex: (
    key: RedisKey,
    index: number | string,
    callback?: Callback<string | null>
) => Result<string | null, 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

method lindexBuffer

lindexBuffer: (
    key: RedisKey,
    index: number | string,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method linsert

linsert: {
    (
        key: RedisKey,
        before: 'BEFORE',
        pivot: string | Buffer | number,
        element: string | Buffer | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        after: 'AFTER',
        pivot: any,
        element: any,
        callback?: Callback<number>
    ): Result<number, 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

method llen

llen: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the length of a list - _group_: list - _complexity_: O(1) - _since_: 1.0.0

method lmove

lmove: {
    (
        source: RedisKey,
        destination: RedisKey,
        left: 'LEFT',
        left1: 'LEFT',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        source: any,
        destination: any,
        left: 'LEFT',
        right: 'RIGHT',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        left: 'LEFT',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        right1: 'RIGHT',
        callback?: Callback<string>
    ): Result<string, Context>;
};

Pop an element from a list, push it to another list and return it - _group_: list - _complexity_: O(1) - _since_: 6.2.0

method lmoveBuffer

lmoveBuffer: {
    (
        source: RedisKey,
        destination: RedisKey,
        left: 'LEFT',
        left1: 'LEFT',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        source: any,
        destination: any,
        left: 'LEFT',
        right: 'RIGHT',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        left: 'LEFT',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
    (
        source: any,
        destination: any,
        right: 'RIGHT',
        right1: 'RIGHT',
        callback?: Callback<Buffer>
    ): Result<Buffer, Context>;
};

method lmpop

lmpop: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            left: 'LEFT',
            callback: Callback<[key: string, members: string[]] | null>
        ]
    ): Result<[key: string, members: string[]] | null, Context>;
    (
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (...args: [numkeys: string | number, ...keys: any[], left: 'LEFT']): Result<
        [key: string, members: string[]],
        Context
    >;
    (numkeys: string | number, keys: any[], left: 'LEFT'): Result<
        [key: string, members: string[]],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: string, members: string[]]>
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            callback: Callback<[key: string, members: string[]]>
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [numkeys: string | number, ...keys: any[], right: 'RIGHT']
    ): Result<[key: string, members: string[]], Context>;
    (numkeys: string | number, keys: any[], right: 'RIGHT'): Result<
        [key: string, members: string[]],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: string, members: string[]]>
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: string, members: string[]]>
    ): Result<[key: string, members: string[]], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: string, members: string[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: string, members: string[]], 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

method lmpopBuffer

lmpopBuffer: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            left: 'LEFT',
            callback: Callback<[key: Buffer, members: Buffer[]] | null>
        ]
    ): Result<[key: Buffer, members: Buffer[]] | null, Context>;
    (
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (...args: [numkeys: string | number, ...keys: any[], left: 'LEFT']): Result<
        [key: Buffer, members: Buffer[]],
        Context
    >;
    (numkeys: string | number, keys: any[], left: 'LEFT'): Result<
        [key: Buffer, members: Buffer[]],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: Buffer, members: Buffer[]]>
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            left: 'LEFT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        left: 'LEFT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            callback: Callback<[key: Buffer, members: Buffer[]]>
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [numkeys: string | number, ...keys: any[], right: 'RIGHT']
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (numkeys: string | number, keys: any[], right: 'RIGHT'): Result<
        [key: Buffer, members: Buffer[]],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<[key: Buffer, members: Buffer[]]>
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<[key: Buffer, members: Buffer[]]>
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            right: 'RIGHT',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<[key: Buffer, members: Buffer[]], Context>;
    (
        numkeys: string | number,
        keys: any[],
        right: 'RIGHT',
        countToken: 'COUNT',
        count: string | number
    ): Result<[key: Buffer, members: Buffer[]], Context>;
};

method lolwut

lolwut: {
    (callback?: Callback<string>): Result<string, Context>;
    (
        versionToken: 'VERSION',
        version: string | number,
        callback?: Callback<string>
    ): Result<string, Context>;
};

Display some computer art and the Redis version - _group_: server - _complexity_: undefined - _since_: 5.0.0

method lpop

lpop: {
    (key: RedisKey, callback?: Callback<string | null>): Result<
        string | null,
        Context
    >;
    (key: any, count: string | number, 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

method lpopBuffer

lpopBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
};

method lpos

lpos: {
    (
        key: RedisKey,
        element: string | Buffer | number,
        callback?: Callback<number | null>
    ): Result<number | null, Context>;
    (
        key: any,
        element: any,
        lenToken: 'MAXLEN',
        len: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        element: any,
        numMatchesToken: 'COUNT',
        numMatches: string | number,
        callback?: Callback<number[]>
    ): Result<number[], Context>;
    (
        key: any,
        element: any,
        numMatchesToken: 'COUNT',
        numMatches: string | number,
        lenToken: 'MAXLEN',
        len: string | number,
        callback?: Callback<number[]>
    ): Result<number[], Context>;
    (
        key: any,
        element: any,
        rankToken: 'RANK',
        rank: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        element: any,
        rankToken: 'RANK',
        rank: string | number,
        lenToken: 'MAXLEN',
        len: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        element: any,
        rankToken: 'RANK',
        rank: string | number,
        numMatchesToken: 'COUNT',
        numMatches: string | number,
        callback?: Callback<number[]>
    ): Result<number[], Context>;
    (
        key: any,
        element: any,
        rankToken: 'RANK',
        rank: string | number,
        numMatchesToken: 'COUNT',
        numMatches: string | number,
        lenToken: 'MAXLEN',
        len: string | number,
        callback?: Callback<number[]>
    ): Result<number[], 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

method lpush

lpush: {
    (
        ...args: [
            key: RedisKey,
            ...elements: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...elements: any[]): 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

method lpushx

lpushx: {
    (
        ...args: [
            key: RedisKey,
            ...elements: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...elements: any[]): 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

method lrange

lrange: (
    key: RedisKey,
    start: number | string,
    stop: number | string,
    callback?: Callback<string[]>
) => Result<string[], 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

method lrangeBuffer

lrangeBuffer: (
    key: RedisKey,
    start: number | string,
    stop: number | string,
    callback?: Callback<Buffer[]>
) => Result<Buffer[], Context>;

method lrem

lrem: (
    key: RedisKey,
    count: number | string,
    element: string | Buffer | number,
    callback?: Callback<number>
) => Result<number, 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

method lset

lset: (
    key: RedisKey,
    index: number | string,
    element: string | Buffer | number,
    callback?: Callback<'OK'>
) => Result<'OK', 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

method ltrim

ltrim: (
    key: RedisKey,
    start: number | string,
    stop: number | string,
    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

method memory

memory: {
    (subcommand: 'DOCTOR', callback?: Callback<string>): Result<string, Context>;
    (subcommand: 'HELP', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'MALLOC-STATS', callback?: Callback<string>): Result<
        string,
        Context
    >;
    (subcommand: 'PURGE', callback?: Callback<'OK'>): Result<'OK', Context>;
    (subcommand: 'STATS', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'USAGE', key: any, callback?: Callback<number>): Result<
        number,
        Context
    >;
    (
        subcommand: 'USAGE',
        key: any,
        countToken: 'SAMPLES',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
};

Outputs memory problems report - _group_: server - _complexity_: O(1) - _since_: 4.0.0
Show helpful text about the different subcommands - _group_: server - _complexity_: O(1) - _since_: 4.0.0
Show allocator internal stats - _group_: server - _complexity_: Depends on how much memory is allocated, could be slow - _since_: 4.0.0
Ask the allocator to release memory - _group_: server - _complexity_: Depends on how much memory is allocated, could be slow - _since_: 4.0.0
Show memory usage details - _group_: server - _complexity_: O(1) - _since_: 4.0.0
Estimate the memory usage of a key - _group_: server - _complexity_: O(N) where N is the number of samples. - _since_: 4.0.0

method mget

mget: {
    (
        ...args: [...keys: RedisKey[], callback: Callback<(string | null)[]>]
    ): Result<(string | null)[], Context>;
    (keys: any[], callback: Callback<string[]>): Result<string[], Context>;
    (...args: any[]): Result<string[], Context>;
    (keys: any[]): Result<string[], 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

method mgetBuffer

mgetBuffer: {
    (
        ...args: [...keys: RedisKey[], callback: Callback<(Buffer | null)[]>]
    ): Result<(Buffer | null)[], Context>;
    (keys: any[], callback: Callback<any[]>): Result<any[], Context>;
    (...args: any[]): Result<any[], Context>;
    (keys: any[]): Result<any[], Context>;
};

method migrate

migrate: {
    (
        ...args: [
            host: any,
            port: string | number,
            ...args: any[],
            callback: Callback<'OK'>
        ]
    ): Result<'OK', Context>;
    (host: any, port: string | number, ...args: any[]): Result<'OK', 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

method module

module: {
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'LIST', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'LOAD', path: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'LOAD',
            path: any,
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: 'LOAD', path: any, ...args: any[]): Result<unknown, Context>;
    (subcommand: 'LOADEX', path: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'LOADEX',
            path: any,
            argsToken: 'ARGS',
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: 'LOADEX', path: any, argsToken: 'ARGS', ...args: any[]): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'LOADEX',
            path: any,
            configsToken: 'CONFIG',
            ...configs: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        subcommand: 'LOADEX',
        path: any,
        configsToken: 'CONFIG',
        ...configs: any[]
    ): Result<unknown, Context>;
    (
        ...args: [
            subcommand: 'LOADEX',
            path: any,
            configsToken: 'CONFIG',
            ...args: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        subcommand: 'LOADEX',
        path: any,
        configsToken: 'CONFIG',
        ...args: any[]
    ): Result<unknown, Context>;
    (subcommand: 'UNLOAD', name: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
};

Show helpful text about the different subcommands - _group_: server - _complexity_: O(1) - _since_: 5.0.0
List all modules loaded by the server - _group_: server - _complexity_: O(N) where N is the number of loaded modules. - _since_: 4.0.0
Load a module - _group_: server - _complexity_: O(1) - _since_: 4.0.0
Load a module with extended parameters - _group_: server - _complexity_: O(1) - _since_: 7.0.0
Unload a module - _group_: server - _complexity_: O(1) - _since_: 4.0.0

method move

move: (
    key: RedisKey,
    db: number | string,
    callback?: Callback<number>
) => Result<number, Context>;

Move a key to another database - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method mset

mset: {
    (object: object, callback?: Callback<'OK'>): Result<'OK', Context>;
    (map: Map<any, any>, callback?: Callback<'OK'>): Result<'OK', Context>;
    (...args: [...keyValues: any[], callback: Callback<'OK'>]): Result<
        'OK',
        Context
    >;
    (...args: any[]): Result<'OK', 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

method msetnx

msetnx: {
    (object: object, callback?: Callback<'OK'>): Result<'OK', Context>;
    (map: Map<any, any>, callback?: Callback<'OK'>): Result<'OK', Context>;
    (...args: [...keyValues: any[], callback: Callback<number>]): Result<
        number,
        Context
    >;
    (...args: any[]): Result<number, 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

method object

object: {
    (
        subcommand: 'ENCODING',
        key: RedisKey,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (subcommand: 'FREQ', key: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'IDLETIME', key: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'REFCOUNT', key: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
};

Inspect the internal encoding of a Redis object - _group_: generic - _complexity_: O(1) - _since_: 2.2.3
Get the logarithmic access frequency counter of a Redis object - _group_: generic - _complexity_: O(1) - _since_: 4.0.0
Show helpful text about the different subcommands - _group_: generic - _complexity_: O(1) - _since_: 6.2.0
Get the time since a Redis object was last accessed - _group_: generic - _complexity_: O(1) - _since_: 2.2.3
Get the number of references to the value of the key - _group_: generic - _complexity_: O(1) - _since_: 2.2.3

method persist

persist: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Remove the expiration from a key - _group_: generic - _complexity_: O(1) - _since_: 2.2.0

method pexpire

pexpire: {
    (
        key: RedisKey,
        milliseconds: number | string,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        milliseconds: string | number,
        nx: 'NX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        milliseconds: string | number,
        xx: 'XX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        milliseconds: string | number,
        gt: 'GT',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        milliseconds: string | number,
        lt: 'LT',
        callback?: Callback<number>
    ): Result<number, Context>;
};

Set a key's time to live in milliseconds - _group_: generic - _complexity_: O(1) - _since_: 2.6.0

method pexpireat

pexpireat: {
    (
        key: RedisKey,
        unixTimeMilliseconds: number | string,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeMilliseconds: string | number,
        nx: 'NX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeMilliseconds: string | number,
        xx: 'XX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeMilliseconds: string | number,
        gt: 'GT',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        unixTimeMilliseconds: string | number,
        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

method pexpiretime

pexpiretime: (
    key: RedisKey,
    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

method pfadd

pfadd: {
    (key: RedisKey, callback?: Callback<number>): Result<number, Context>;
    (
        ...args: [key: any, ...elements: any[], callback: Callback<number>]
    ): Result<number, Context>;
    (key: any, ...elements: any[]): Result<number, Context>;
};

Adds the specified elements to the specified HyperLogLog. - _group_: hyperloglog - _complexity_: O(1) to add every element. - _since_: 2.8.9

method pfcount

pfcount: {
    (...args: [...keys: RedisKey[], callback: Callback<number>]): Result<
        number,
        Context
    >;
    (keys: any[], callback: Callback<number>): Result<number, Context>;
    (...args: any[]): Result<number, Context>;
    (keys: any[]): 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

method pfdebug

pfdebug: (
    subcommand: string | Buffer,
    key: RedisKey,
    callback?: Callback<unknown>
) => Result<unknown, Context>;

Internal commands for debugging HyperLogLog values - _group_: hyperloglog - _complexity_: N/A - _since_: 2.8.9

method pfmerge

pfmerge: {
    (
        ...args: [
            destkey: RedisKey,
            ...sourcekeys: RedisKey[],
            callback: Callback<'OK'>
        ]
    ): Result<'OK', Context>;
    (destkey: any, sourcekeys: any[], callback: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (destkey: any, ...sourcekeys: any[]): Result<'OK', Context>;
    (destkey: any, sourcekeys: any[]): Result<'OK', 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

method pfselftest

pfselftest: (callback?: Callback<unknown>) => Result<unknown, Context>;

An internal command for testing HyperLogLog values - _group_: hyperloglog - _complexity_: N/A - _since_: 2.8.9

method ping

ping: {
    (callback?: Callback<'PONG'>): Result<'PONG', Context>;
    (message: any, callback?: Callback<string>): Result<string, Context>;
};

Ping the server - _group_: connection - _complexity_: O(1) - _since_: 1.0.0

method pingBuffer

pingBuffer: (
    message: string | Buffer,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method psetex

psetex: (
    key: RedisKey,
    milliseconds: number | string,
    value: string | Buffer | number,
    callback?: Callback<unknown>
) => Result<unknown, Context>;

Set the value and expiration in milliseconds of a key - _group_: string - _complexity_: O(1) - _since_: 2.6.0

method psubscribe

psubscribe: {
    (...args: [...patterns: string[], callback: Callback<unknown>]): Result<
        unknown,
        Context
    >;
    (...args: string[]): 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

method psync

psync: (
    replicationid: string | Buffer | number,
    offset: number | string,
    callback?: Callback<unknown>
) => Result<unknown, Context>;

Internal command used for replication - _group_: server - _complexity_: undefined - _since_: 2.8.0

method pttl

pttl: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the time to live for a key in milliseconds - _group_: generic - _complexity_: O(1) - _since_: 2.6.0

method publish

publish: (
    channel: string | Buffer,
    message: string | Buffer,
    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

method pubsub

pubsub: {
    (subcommand: 'CHANNELS', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        subcommand: 'CHANNELS',
        pattern: string,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (subcommand: 'HELP', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'NUMPAT', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (subcommand: 'NUMSUB', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        ...args: [
            subcommand: 'NUMSUB',
            ...channels: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (subcommand: 'NUMSUB', ...channels: any[]): Result<unknown[], Context>;
    (subcommand: 'SHARDCHANNELS', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        subcommand: 'SHARDCHANNELS',
        pattern: string,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (subcommand: 'SHARDNUMSUB', callback?: Callback<unknown[]>): Result<
        unknown[],
        Context
    >;
    (
        ...args: [
            subcommand: 'SHARDNUMSUB',
            ...shardchannels: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (subcommand: 'SHARDNUMSUB', ...shardchannels: any[]): Result<
        unknown[],
        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
Show helpful text about the different subcommands - _group_: pubsub - _complexity_: O(1) - _since_: 6.2.0
Get the count of unique patterns pattern subscriptions - _group_: pubsub - _complexity_: O(1) - _since_: 2.8.0
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
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
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

method punsubscribe

punsubscribe: {
    (callback?: Callback<unknown>): Result<unknown, Context>;
    (...args: [...patterns: string[], callback: Callback<unknown>]): Result<
        unknown,
        Context
    >;
    (...args: string[]): 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

method quit

quit: (callback?: Callback<'OK'>) => Result<'OK', Context>;

Close the connection - _group_: connection - _complexity_: O(1) - _since_: 1.0.0

method randomkey

randomkey: (
    callback?: Callback<string | null>
) => Result<string | null, Context>;

Return a random key from the keyspace - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method randomkeyBuffer

randomkeyBuffer: (
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method readonly

readonly: (callback?: Callback<'OK'>) => Result<'OK', Context>;

Enables read queries for a connection to a cluster replica node - _group_: cluster - _complexity_: O(1) - _since_: 3.0.0

method readwrite

readwrite: (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

method rename

rename: (
    key: RedisKey,
    newkey: RedisKey,
    callback?: Callback<'OK'>
) => Result<'OK', Context>;

Rename a key - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method renamenx

renamenx: (
    key: RedisKey,
    newkey: RedisKey,
    callback?: Callback<number>
) => Result<number, Context>;

Rename a key, only if the new key does not exist - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method replconf

replconf: (callback?: Callback<unknown>) => Result<unknown, Context>;

An internal command for configuring the replication stream - _group_: server - _complexity_: O(1) - _since_: 3.0.0

method replicaof

replicaof: (
    host: string | Buffer,
    port: number | string,
    callback?: Callback<'OK'>
) => Result<'OK', Context>;

Make the server a replica of another instance, or promote it as master. - _group_: server - _complexity_: O(1) - _since_: 5.0.0

method reset

reset: (callback?: Callback<'OK'>) => Result<'OK', Context>;

Reset the connection - _group_: connection - _complexity_: O(1) - _since_: 6.2.0

method restore

restore: {
    (
        key: RedisKey,
        ttl: number | string,
        serializedValue: string | Buffer | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        frequencyToken: 'FREQ',
        frequency: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        ttl: string | number,
        serializedValue: any,
        replace: 'REPLACE',
        absttl: 'ABSTTL',
        secondsToken: 'IDLETIME',
        seconds: string | number,
        frequencyToken: 'FREQ',
        frequency: string | number,
        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

method role

role: (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

method rpop

rpop: {
    (key: RedisKey, callback?: Callback<string | null>): Result<
        string | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<string[]>): Result<
        string[],
        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

method rpopBuffer

rpopBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
};

method rpoplpush

rpoplpush: (
    source: RedisKey,
    destination: RedisKey,
    callback?: Callback<string>
) => Result<string, 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

method rpoplpushBuffer

rpoplpushBuffer: (
    source: RedisKey,
    destination: RedisKey,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method rpush

rpush: {
    (
        ...args: [
            key: RedisKey,
            ...elements: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...elements: any[]): Result<number, 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

method rpushx

rpushx: {
    (
        ...args: [
            key: RedisKey,
            ...elements: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...elements: any[]): 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

method sadd

sadd: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, members: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (key: any, ...members: any[]): Result<number, Context>;
    (key: any, members: any[]): 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

method save

save: (callback?: Callback<'OK'>) => Result<'OK', 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

method scan

scan: {
    (
        cursor: number | string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], 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

method scanBuffer

scanBuffer: {
    (
        cursor: number | string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        typeToken: 'TYPE',
        type: any,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
};

method scard

scard: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the number of members in a set - _group_: set - _complexity_: O(1) - _since_: 1.0.0

method script

script: {
    (subcommand: 'DEBUG', yes: 'YES', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'DEBUG', sync: 'SYNC', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'DEBUG', no: 'NO', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            subcommand: 'EXISTS',
            ...sha1s: any[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (subcommand: 'EXISTS', ...sha1s: any[]): Result<unknown, Context>;
    (subcommand: 'FLUSH', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'FLUSH', async: 'ASYNC', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'FLUSH', sync: 'SYNC', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'KILL', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'LOAD', script: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
};

Set the debug mode for executed scripts. - _group_: scripting - _complexity_: O(1) - _since_: 3.2.0
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
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
Show helpful text about the different subcommands - _group_: scripting - _complexity_: O(1) - _since_: 5.0.0
Kill the script currently in execution. - _group_: scripting - _complexity_: O(1) - _since_: 2.6.0
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

method sdiff

sdiff: {
    (...args: [...keys: RedisKey[], callback: Callback<string[]>]): Result<
        string[],
        Context
    >;
    (keys: any[], callback: Callback<string[]>): Result<string[], Context>;
    (...args: any[]): Result<string[], Context>;
    (keys: any[]): Result<string[], 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

method sdiffBuffer

sdiffBuffer: {
    (...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Result<
        Buffer[],
        Context
    >;
    (keys: any[], callback: Callback<Buffer[]>): Result<Buffer[], Context>;
    (...args: any[]): Result<Buffer[], Context>;
    (keys: any[]): Result<Buffer[], Context>;
};

method sdiffstore

sdiffstore: {
    (
        ...args: [
            destination: RedisKey,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (destination: any, keys: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (destination: any, ...keys: any[]): Result<number, Context>;
    (destination: any, keys: any[]): Result<number, 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

method select

select: (
    index: number | string,
    callback?: Callback<'OK'>
) => Result<'OK', Context>;

Change the selected database for the current connection - _group_: connection - _complexity_: O(1) - _since_: 1.0.0

method set

set: {
    (
        key: RedisKey,
        value: string | Buffer | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (key: any, value: any, get: 'GET', callback?: Callback<string>): Result<
        string,
        Context
    >;
    (key: any, value: any, nx: 'NX', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        key: any,
        value: any,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (key: any, value: any, xx: 'XX', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        key: any,
        value: any,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        nx: 'NX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        xx: 'XX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        nx: 'NX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        xx: 'XX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        nx: 'NX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        xx: 'XX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        nx: 'NX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        xx: 'XX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        nx: 'NX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        nx: 'NX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        xx: 'XX',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        xx: 'XX',
        get: 'GET',
        callback?: Callback<string>
    ): Result<string, Context>;
};

Set the string value of a key - _group_: string - _complexity_: O(1) - _since_: 1.0.0

method setbit

setbit: (
    key: RedisKey,
    offset: number | string,
    value: number | string,
    callback?: Callback<number>
) => Result<number, Context>;

Sets or clears the bit at offset in the string value stored at key - _group_: bitmap - _complexity_: O(1) - _since_: 2.2.0

method setBuffer

setBuffer: {
    (
        key: RedisKey,
        value: string | Buffer | number,
        get: 'GET',
        callback?: Callback<Buffer | null>
    ): Result<Buffer | null, Context>;
    (
        key: any,
        value: any,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        secondsToken: 'EX',
        seconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        millisecondsToken: 'PX',
        milliseconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        unixTimeSecondsToken: 'EXAT',
        unixTimeSeconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        nx: 'NX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        unixTimeMillisecondsToken: 'PXAT',
        unixTimeMilliseconds: string | number,
        xx: 'XX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        nx: 'NX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
    (
        key: any,
        value: any,
        keepttl: 'KEEPTTL',
        xx: 'XX',
        get: 'GET',
        callback?: Callback<any>
    ): Result<any, Context>;
};

method setex

setex: (
    key: RedisKey,
    seconds: number | string,
    value: string | Buffer | number,
    callback?: Callback<'OK'>
) => Result<'OK', Context>;

Set the value and expiration of a key - _group_: string - _complexity_: O(1) - _since_: 2.0.0

method setnx

setnx: (
    key: RedisKey,
    value: string | Buffer | number,
    callback?: Callback<number>
) => Result<number, Context>;

Set the value of a key, only if the key does not exist - _group_: string - _complexity_: O(1) - _since_: 1.0.0

method setrange

setrange: (
    key: RedisKey,
    offset: number | string,
    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

method shutdown

shutdown: {
    (callback?: Callback<'OK'>): Result<'OK', Context>;
    (abort: 'ABORT', callback?: Callback<'OK'>): Result<'OK', Context>;
    (force: 'FORCE', callback?: Callback<'OK'>): Result<'OK', Context>;
    (force: 'FORCE', abort: 'ABORT', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (now: 'NOW', callback?: Callback<'OK'>): Result<'OK', Context>;
    (now: 'NOW', abort: 'ABORT', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (now: 'NOW', force: 'FORCE', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        now: 'NOW',
        force: 'FORCE',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (nosave: 'NOSAVE', callback?: Callback<'OK'>): Result<'OK', Context>;
    (nosave: 'NOSAVE', abort: 'ABORT', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (nosave: 'NOSAVE', force: 'FORCE', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        nosave: 'NOSAVE',
        force: 'FORCE',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (nosave: 'NOSAVE', now: 'NOW', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        nosave: 'NOSAVE',
        now: 'NOW',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        nosave: 'NOSAVE',
        now: 'NOW',
        force: 'FORCE',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        nosave: 'NOSAVE',
        now: 'NOW',
        force: 'FORCE',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (save: 'SAVE', callback?: Callback<'OK'>): Result<'OK', Context>;
    (save: 'SAVE', abort: 'ABORT', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (save: 'SAVE', force: 'FORCE', callback?: Callback<'OK'>): Result<
        'OK',
        Context
    >;
    (
        save: 'SAVE',
        force: 'FORCE',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (save: 'SAVE', now: 'NOW', callback?: Callback<'OK'>): Result<'OK', Context>;
    (
        save: 'SAVE',
        now: 'NOW',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        save: 'SAVE',
        now: 'NOW',
        force: 'FORCE',
        callback?: Callback<'OK'>
    ): Result<'OK', Context>;
    (
        save: 'SAVE',
        now: 'NOW',
        force: 'FORCE',
        abort: 'ABORT',
        callback?: Callback<'OK'>
    ): Result<'OK', 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

method sinter

sinter: {
    (...args: [...keys: RedisKey[], callback: Callback<string[]>]): Result<
        string[],
        Context
    >;
    (keys: any[], callback: Callback<string[]>): Result<string[], Context>;
    (...args: any[]): Result<string[], Context>;
    (keys: any[]): Result<string[], 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

method sinterBuffer

sinterBuffer: {
    (...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Result<
        Buffer[],
        Context
    >;
    (keys: any[], callback: Callback<Buffer[]>): Result<Buffer[], Context>;
    (...args: any[]): Result<Buffer[], Context>;
    (keys: any[]): Result<Buffer[], Context>;
};

method sintercard

sintercard: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (numkeys: string | number, keys: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (numkeys: string | number, ...keys: any[]): Result<number, Context>;
    (numkeys: string | number, keys: any[]): Result<number, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            limitToken: 'LIMIT',
            limit: string | number,
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        numkeys: string | number,
        keys: any[],
        limitToken: 'LIMIT',
        limit: string | number,
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            limitToken: 'LIMIT',
            limit: string | number
        ]
    ): Result<number, Context>;
    (
        numkeys: string | number,
        keys: any[],
        limitToken: 'LIMIT',
        limit: string | number
    ): Result<number, 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

method sinterstore

sinterstore: {
    (
        ...args: [
            destination: RedisKey,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (destination: any, keys: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (destination: any, ...keys: any[]): Result<number, Context>;
    (destination: any, keys: any[]): 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

method sismember

sismember: (
    key: RedisKey,
    member: string | Buffer | number,
    callback?: Callback<number>
) => Result<number, Context>;

Determine if a given value is a member of a set - _group_: set - _complexity_: O(1) - _since_: 1.0.0

method slaveof

slaveof: (
    host: string | Buffer,
    port: number | string,
    callback?: Callback<'OK'>
) => Result<'OK', Context>;

Make the server a replica of another instance, or promote it as master. - _group_: server - _complexity_: O(1) - _since_: 1.0.0

method slowlog

slowlog: {
    (subcommand: 'GET', callback?: Callback<unknown>): Result<unknown, Context>;
    (
        subcommand: 'GET',
        count: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'LEN', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'RESET', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
};

Get the slow log's entries - _group_: server - _complexity_: O(N) where N is the number of entries returned - _since_: 2.2.12
Show helpful text about the different subcommands - _group_: server - _complexity_: O(1) - _since_: 6.2.0
Get the slow log's length - _group_: server - _complexity_: O(1) - _since_: 2.2.12
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

method smembers

smembers: (
    key: RedisKey,
    callback?: Callback<string[]>
) => Result<string[], Context>;

Get all the members in a set - _group_: set - _complexity_: O(N) where N is the set cardinality. - _since_: 1.0.0

method smembersBuffer

smembersBuffer: (
    key: RedisKey,
    callback?: Callback<Buffer[]>
) => Result<Buffer[], Context>;

method smismember

smismember: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<number[]>
        ]
    ): Result<number[], Context>;
    (key: any, members: any[], callback: Callback<number[]>): Result<
        number[],
        Context
    >;
    (key: any, ...members: any[]): Result<number[], Context>;
    (key: any, members: any[]): Result<number[], 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

method smove

smove: (
    source: RedisKey,
    destination: RedisKey,
    member: string | Buffer | number,
    callback?: Callback<number>
) => Result<number, Context>;

Move a member from one set to another - _group_: set - _complexity_: O(1) - _since_: 1.0.0

method sort

sort: {
    (...args: [key: any, ...args: any[], callback: Callback<unknown>]): Result<
        unknown,
        Context
    >;
    (key: any, ...args: any[]): Result<unknown, 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

method sort_ro

sort_ro: {
    (key: RedisKey, callback?: Callback<unknown>): Result<unknown, Context>;
    (key: any, alpha: 'ALPHA', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (key: any, asc: 'ASC', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (key: any, asc: 'ASC', alpha: 'ALPHA', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (key: any, desc: 'DESC', callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        key: any,
        desc: 'DESC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (key: any, patternToken: 'GET', ...patterns: string[]): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        asc: 'ASC',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        asc: 'ASC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        desc: 'DESC',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        desc: 'DESC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        patternToken: 'GET',
        ...patterns: string[]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            asc: 'ASC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken: 'GET',
            ...patterns: string[],
            desc: 'DESC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        asc: 'ASC',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        asc: 'ASC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        desc: 'DESC',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        desc: 'DESC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        patternToken1: 'GET',
        ...pattern1s: string[]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        asc: 'ASC',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        asc: 'ASC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        desc: 'DESC',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        desc: 'DESC',
        alpha: 'ALPHA',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        key: any,
        patternToken: 'BY',
        pattern: string,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        patternToken1: 'GET',
        ...pattern1s: string[]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            asc: 'ASC',
            alpha: 'ALPHA'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC'
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC',
            alpha: 'ALPHA',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        ...args: [
            key: any,
            patternToken: 'BY',
            pattern: string,
            offsetCountToken: 'LIMIT',
            offset: string | number,
            count: string | number,
            patternToken1: 'GET',
            ...pattern1s: string[],
            desc: 'DESC',
            alpha: 'ALPHA'
        ]
    ): 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

method spop

spop: {
    (key: RedisKey, callback?: Callback<string | null>): Result<
        string | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<string[]>): Result<
        string[],
        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

method spopBuffer

spopBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
};

method spublish

spublish: (
    shardchannel: string | Buffer,
    message: string | Buffer,
    callback?: Callback<unknown>
) => Result<unknown, 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

method srandmember

srandmember: {
    (key: RedisKey, callback?: Callback<string | null>): Result<
        string | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<string[]>): Result<
        string[],
        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

method srandmemberBuffer

srandmemberBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
};

method srem

srem: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, members: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (key: any, ...members: any[]): Result<number, Context>;
    (key: any, members: any[]): Result<number, 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

method sscan

sscan: {
    (
        key: RedisKey,
        cursor: number | string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], 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

method sscanBuffer

sscanBuffer: {
    (
        key: RedisKey,
        cursor: number | string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
};

method ssubscribe

ssubscribe: {
    (
        ...args: [
            ...shardchannels: (string | Buffer)[],
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (...args: any[]): Result<unknown, 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

method strlen

strlen: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the length of the value stored in a key - _group_: string - _complexity_: O(1) - _since_: 2.2.0

subscribe: {
    (
        ...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]
    ): Result<unknown, Context>;
    (...args: any[]): Result<unknown, 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

method substr

substr: (
    key: RedisKey,
    start: number | string,
    end: number | string,
    callback?: Callback<unknown>
) => 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

method sunion

sunion: {
    (...args: [...keys: RedisKey[], callback: Callback<string[]>]): Result<
        string[],
        Context
    >;
    (keys: any[], callback: Callback<string[]>): Result<string[], Context>;
    (...args: any[]): Result<string[], Context>;
    (keys: any[]): Result<string[], 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

method sunionBuffer

sunionBuffer: {
    (...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]): Result<
        Buffer[],
        Context
    >;
    (keys: any[], callback: Callback<Buffer[]>): Result<Buffer[], Context>;
    (...args: any[]): Result<Buffer[], Context>;
    (keys: any[]): Result<Buffer[], Context>;
};

method sunionstore

sunionstore: {
    (
        ...args: [
            destination: RedisKey,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (destination: any, keys: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (destination: any, ...keys: any[]): Result<number, Context>;
    (destination: any, keys: any[]): Result<number, 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

method sunsubscribe

sunsubscribe: {
    (callback?: Callback<unknown>): Result<unknown, Context>;
    (...args: [...shardchannels: any[], callback: Callback<unknown>]): Result<
        unknown,
        Context
    >;
    (...args: any[]): Result<unknown, 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

method swapdb

swapdb: (
    index1: number | string,
    index2: number | string,
    callback?: Callback<'OK'>
) => Result<'OK', 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

method sync

sync: (callback?: Callback<unknown>) => Result<unknown, Context>;

Internal command used for replication - _group_: server - _complexity_: undefined - _since_: 1.0.0

method time

time: (callback?: Callback<number[]>) => Result<number[], Context>;

Return the current server time - _group_: server - _complexity_: O(1) - _since_: 2.6.0

method touch

touch: {
    (...args: [...keys: RedisKey[], callback: Callback<number>]): Result<
        number,
        Context
    >;
    (keys: any[], callback: Callback<number>): Result<number, Context>;
    (...args: any[]): Result<number, Context>;
    (keys: any[]): 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

method ttl

ttl: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the time to live for a key in seconds - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method type

type: (key: RedisKey, callback?: Callback<string>) => Result<string, Context>;

Determine the type stored at key - _group_: generic - _complexity_: O(1) - _since_: 1.0.0

method unlink

unlink: {
    (...args: [...keys: RedisKey[], callback: Callback<number>]): Result<
        number,
        Context
    >;
    (keys: any[], callback: Callback<number>): Result<number, Context>;
    (...args: any[]): Result<number, Context>;
    (keys: any[]): Result<number, 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

method unsubscribe

unsubscribe: {
    (callback?: Callback<unknown>): Result<unknown, Context>;
    (...args: [...channels: any[], callback: Callback<unknown>]): Result<
        unknown,
        Context
    >;
    (...args: any[]): Result<unknown, 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

method unwatch

unwatch: (callback?: Callback<'OK'>) => Result<'OK', Context>;

Forget about all watched keys - _group_: transactions - _complexity_: O(1) - _since_: 2.2.0

method wait

wait: (
    numreplicas: number | string,
    timeout: number | string,
    callback?: Callback<number>
) => Result<number, 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

method watch

watch: {
    (...args: [...keys: RedisKey[], callback: Callback<'OK'>]): Result<
        'OK',
        Context
    >;
    (keys: any[], callback: Callback<'OK'>): Result<'OK', Context>;
    (...args: any[]): Result<'OK', Context>;
    (keys: any[]): Result<'OK', 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

method xack

xack: {
    (
        ...args: [
            key: RedisKey,
            group: string | Buffer,
            ...ids: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, group: any, ...ids: any[]): Result<number, 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

method xadd

xadd: {
    (...args: [key: any, ...args: any[], callback: Callback<string>]): Result<
        string | null,
        Context
    >;
    (key: any, ...args: any[]): Result<string, 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

method xaddBuffer

xaddBuffer: {
    (...args: [key: any, ...args: any[], callback: Callback<any>]): Result<
        Buffer | null,
        Context
    >;
    (key: any, ...args: any[]): Result<any, Context>;
};

method xautoclaim

xautoclaim: {
    (
        key: RedisKey,
        group: string | Buffer,
        consumer: string | Buffer,
        minIdleTime: string | Buffer | number,
        start: string | Buffer | number,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        consumer: any,
        minIdleTime: any,
        start: any,
        justid: 'JUSTID',
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        consumer: any,
        minIdleTime: any,
        start: any,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        consumer: any,
        minIdleTime: any,
        start: any,
        countToken: 'COUNT',
        count: string | number,
        justid: 'JUSTID',
        callback?: Callback<unknown[]>
    ): Result<unknown[], 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

method xclaim

xclaim: {
    (
        ...args: [
            key: RedisKey,
            group: string | Buffer,
            consumer: string | Buffer,
            minIdleTime: string | Buffer | number,
            ...ids: (string | Buffer | number)[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        consumer: any,
        minIdleTime: any,
        ...ids: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            justid: 'JUSTID'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE'
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID',
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        ...args: [
            key: any,
            group: any,
            consumer: any,
            minIdleTime: any,
            ...ids: any[],
            msToken: 'IDLE',
            ms: string | number,
            unixTimeMillisecondsToken: 'TIME',
            unixTimeMilliseconds: string | number,
            countToken: 'RETRYCOUNT',
            count: string | number,
            force: 'FORCE',
            justid: 'JUSTID'
        ]
    ): 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

method xdel

xdel: {
    (
        ...args: [
            key: RedisKey,
            ...ids: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...ids: any[]): Result<number, 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

method xgroup

xgroup: {
    (
        subcommand: 'CREATE',
        key: RedisKey,
        groupname: string | Buffer,
        id: string | Buffer | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        id: any,
        entriesReadToken: 'ENTRIESREAD',
        entriesRead: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        id: any,
        mkstream: 'MKSTREAM',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        id: any,
        mkstream: 'MKSTREAM',
        entriesReadToken: 'ENTRIESREAD',
        entriesRead: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        newId: '$',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        newId: '$',
        entriesReadToken: 'ENTRIESREAD',
        entriesRead: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        newId: '$',
        mkstream: 'MKSTREAM',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATE',
        key: any,
        groupname: any,
        newId: '$',
        mkstream: 'MKSTREAM',
        entriesReadToken: 'ENTRIESREAD',
        entriesRead: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'CREATECONSUMER',
        key: any,
        groupname: any,
        consumername: any,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'DELCONSUMER',
        key: any,
        groupname: any,
        consumername: any,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'DESTROY',
        key: any,
        groupname: any,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (
        subcommand: 'SETID',
        key: any,
        groupname: any,
        id: any,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'SETID',
        key: any,
        groupname: any,
        id: any,
        entriesReadToken: 'ENTRIESREAD',
        entriesRead: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'SETID',
        key: any,
        groupname: any,
        newId: '$',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'SETID',
        key: any,
        groupname: any,
        newId: '$',
        entriesReadToken: 'ENTRIESREAD',
        entriesRead: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
};

Create a consumer group. - _group_: stream - _complexity_: O(1) - _since_: 5.0.0
Create a consumer in a consumer group. - _group_: stream - _complexity_: O(1) - _since_: 6.2.0
Delete a consumer from a consumer group. - _group_: stream - _complexity_: O(1) - _since_: 5.0.0
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
Show helpful text about the different subcommands - _group_: stream - _complexity_: O(1) - _since_: 5.0.0
Set a consumer group to an arbitrary last delivered ID value. - _group_: stream - _complexity_: O(1) - _since_: 5.0.0

method xinfo

xinfo: {
    (
        subcommand: 'CONSUMERS',
        key: RedisKey,
        groupname: string | Buffer,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (subcommand: 'GROUPS', key: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (subcommand: 'HELP', callback?: Callback<unknown>): Result<unknown, Context>;
    (subcommand: 'STREAM', key: any, callback?: Callback<unknown>): Result<
        unknown,
        Context
    >;
    (
        subcommand: 'STREAM',
        key: any,
        fullToken: 'FULL',
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        subcommand: 'STREAM',
        key: any,
        fullToken: 'FULL',
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
};

List the consumers in a consumer group - _group_: stream - _complexity_: O(1) - _since_: 5.0.0
List the consumer groups of a stream - _group_: stream - _complexity_: O(1) - _since_: 5.0.0
Show helpful text about the different subcommands - _group_: stream - _complexity_: O(1) - _since_: 5.0.0
Get information about a stream - _group_: stream - _complexity_: O(1) - _since_: 5.0.0

method xlen

xlen: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Return the number of entries in a stream - _group_: stream - _complexity_: O(1) - _since_: 5.0.0

method xpending

xpending: {
    (
        key: RedisKey,
        group: string | Buffer,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        start: any,
        end: any,
        count: string | number,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        start: any,
        end: any,
        count: string | number,
        consumer: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        minIdleTimeToken: 'IDLE',
        minIdleTime: string | number,
        start: any,
        end: any,
        count: string | number,
        callback?: Callback<unknown[]>
    ): Result<unknown[], Context>;
    (
        key: any,
        group: any,
        minIdleTimeToken: 'IDLE',
        minIdleTime: string | number,
        start: any,
        end: any,
        count: string | number,
        consumer: any,
        callback?: Callback<unknown[]>
    ): Result<unknown[], 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

method xrange

xrange: {
    (
        key: RedisKey,
        start: string | Buffer | number,
        end: string | Buffer | number,
        callback?: Callback<[id: string, fields: string[]][]>
    ): Result<[id: string, fields: string[]][], Context>;
    (
        key: any,
        start: any,
        end: any,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[id: string, fields: string[]][]>
    ): Result<[id: string, fields: string[]][], 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

method xrangeBuffer

xrangeBuffer: {
    (
        key: RedisKey,
        start: string | Buffer | number,
        end: string | Buffer | number,
        callback?: Callback<[id: Buffer, fields: Buffer[]][]>
    ): Result<[id: Buffer, fields: Buffer[]][], Context>;
    (
        key: any,
        start: any,
        end: any,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[id: Buffer, fields: Buffer[]][]>
    ): Result<[id: Buffer, fields: Buffer[]][], Context>;
};

method xread

xread: {
    (
        ...args: [
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: string, items: [id: string, fields: string[]][]][]
            >
        ]
    ): Result<
        [key: string, items: [id: string, fields: string[]][]][] | null,
        Context
    >;
    (streamsToken: 'STREAMS', ...args: any[]): Result<
        [key: string, items: [id: string, fields: string[]][]][],
        Context
    >;
    (
        ...args: [
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: string, items: [id: string, fields: string[]][]][]
            >
        ]
    ): Result<[key: string, items: [id: string, fields: string[]][]][], Context>;
    (
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<[key: string, items: [id: string, fields: string[]][]][], Context>;
    (
        ...args: [
            countToken: 'COUNT',
            count: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: string, items: [id: string, fields: string[]][]][]
            >
        ]
    ): Result<[key: string, items: [id: string, fields: string[]][]][], Context>;
    (
        countToken: 'COUNT',
        count: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<[key: string, items: [id: string, fields: string[]][]][], Context>;
    (
        ...args: [
            countToken: 'COUNT',
            count: string | number,
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: string, items: [id: string, fields: string[]][]][]
            >
        ]
    ): Result<[key: string, items: [id: string, fields: string[]][]][], Context>;
    (
        countToken: 'COUNT',
        count: string | number,
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<[key: string, items: [id: string, fields: string[]][]][], 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

method xreadBuffer

xreadBuffer: {
    (
        ...args: [
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]
            >
        ]
    ): Result<
        [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][] | null,
        Context
    >;
    (streamsToken: 'STREAMS', ...args: any[]): Result<
        [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][],
        Context
    >;
    (
        ...args: [
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]
            >
        ]
    ): Result<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][], Context>;
    (
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][], Context>;
    (
        ...args: [
            countToken: 'COUNT',
            count: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]
            >
        ]
    ): Result<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][], Context>;
    (
        countToken: 'COUNT',
        count: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][], Context>;
    (
        ...args: [
            countToken: 'COUNT',
            count: string | number,
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<
                [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]
            >
        ]
    ): Result<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][], Context>;
    (
        countToken: 'COUNT',
        count: string | number,
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<[key: Buffer, items: [id: Buffer, fields: Buffer[]][]][], Context>;
};

method xreadgroup

xreadgroup: {
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            noack: 'NOACK',
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        noack: 'NOACK',
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            noack: 'NOACK',
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        noack: 'NOACK',
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            countToken: 'COUNT',
            count: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        countToken: 'COUNT',
        count: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            countToken: 'COUNT',
            count: string | number,
            noack: 'NOACK',
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        countToken: 'COUNT',
        count: string | number,
        noack: 'NOACK',
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            countToken: 'COUNT',
            count: string | number,
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        countToken: 'COUNT',
        count: string | number,
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], Context>;
    (
        ...args: [
            groupConsumerToken: 'GROUP',
            group: any,
            consumer: any,
            countToken: 'COUNT',
            count: string | number,
            millisecondsToken: 'BLOCK',
            milliseconds: string | number,
            noack: 'NOACK',
            streamsToken: 'STREAMS',
            ...args: any[],
            callback: Callback<unknown[]>
        ]
    ): Result<unknown[], Context>;
    (
        groupConsumerToken: 'GROUP',
        group: any,
        consumer: any,
        countToken: 'COUNT',
        count: string | number,
        millisecondsToken: 'BLOCK',
        milliseconds: string | number,
        noack: 'NOACK',
        streamsToken: 'STREAMS',
        ...args: any[]
    ): Result<unknown[], 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

method xrevrange

xrevrange: {
    (
        key: RedisKey,
        end: string | Buffer | number,
        start: string | Buffer | number,
        callback?: Callback<[id: string, fields: string[]][]>
    ): Result<[id: string, fields: string[]][], Context>;
    (
        key: any,
        end: any,
        start: any,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[id: string, fields: string[]][]>
    ): Result<[id: string, fields: string[]][], 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

method xrevrangeBuffer

xrevrangeBuffer: {
    (
        key: RedisKey,
        end: string | Buffer | number,
        start: string | Buffer | number,
        callback?: Callback<[id: Buffer, fields: Buffer[]][]>
    ): Result<[id: Buffer, fields: Buffer[]][], Context>;
    (
        key: any,
        end: any,
        start: any,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[id: Buffer, fields: Buffer[]][]>
    ): Result<[id: Buffer, fields: Buffer[]][], Context>;
};

method xsetid

xsetid: {
    (
        key: RedisKey,
        lastId: string | Buffer | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        lastId: any,
        maxDeletedEntryIdToken: 'MAXDELETEDID',
        maxDeletedEntryId: any,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        lastId: any,
        entriesAddedToken: 'ENTRIESADDED',
        entriesAdded: string | number,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
    (
        key: any,
        lastId: any,
        entriesAddedToken: 'ENTRIESADDED',
        entriesAdded: string | number,
        maxDeletedEntryIdToken: 'MAXDELETEDID',
        maxDeletedEntryId: any,
        callback?: Callback<unknown>
    ): Result<unknown, Context>;
};

An internal command for replicating stream values - _group_: stream - _complexity_: O(1) - _since_: 5.0.0

method xtrim

xtrim: {
    (
        key: RedisKey,
        maxlen: 'MAXLEN',
        threshold: string | Buffer | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        maxlen: 'MAXLEN',
        threshold: any,
        countToken: 'LIMIT',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        maxlen: 'MAXLEN',
        equal: '=',
        threshold: any,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        maxlen: 'MAXLEN',
        equal: '=',
        threshold: any,
        countToken: 'LIMIT',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        maxlen: 'MAXLEN',
        approximately: '~',
        threshold: any,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        maxlen: 'MAXLEN',
        approximately: '~',
        threshold: any,
        countToken: 'LIMIT',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        minid: 'MINID',
        threshold: any,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        minid: 'MINID',
        threshold: any,
        countToken: 'LIMIT',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        minid: 'MINID',
        equal: '=',
        threshold: any,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        minid: 'MINID',
        equal: '=',
        threshold: any,
        countToken: 'LIMIT',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        minid: 'MINID',
        approximately: '~',
        threshold: any,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        key: any,
        minid: 'MINID',
        approximately: '~',
        threshold: any,
        countToken: 'LIMIT',
        count: string | number,
        callback?: Callback<number>
    ): Result<number, 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

method zadd

zadd: {
    (
        ...args: [
            key: RedisKey,
            ...scoreMembers: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ...scoreMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, incr: 'INCR', ...scoreMembers: any[]): Result<string, Context>;
    (
        ...args: [
            key: any,
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, ch: 'CH', ...scoreMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            gt: 'GT',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, gt: 'GT', ...scoreMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            gt: 'GT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, gt: 'GT', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            gt: 'GT',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, gt: 'GT', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            gt: 'GT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, gt: 'GT', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            lt: 'LT',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, lt: 'LT', ...scoreMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            lt: 'LT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, lt: 'LT', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            lt: 'LT',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, lt: 'LT', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            lt: 'LT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, lt: 'LT', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', ...scoreMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            nx: 'NX',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, nx: 'NX', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, nx: 'NX', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            gt: 'GT',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', gt: 'GT', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            gt: 'GT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, nx: 'NX', gt: 'GT', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            gt: 'GT',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', gt: 'GT', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            gt: 'GT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (
        key: any,
        nx: 'NX',
        gt: 'GT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<string, Context>;
    (
        ...args: [
            key: any,
            nx: 'NX',
            lt: 'LT',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', lt: 'LT', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            lt: 'LT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, nx: 'NX', lt: 'LT', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            lt: 'LT',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, nx: 'NX', lt: 'LT', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            lt: 'LT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (
        key: any,
        nx: 'NX',
        lt: 'LT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<string, Context>;
    (
        ...args: [
            key: any,
            xx: 'XX',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', ...scoreMembers: any[]): Result<number, Context>;
    (
        ...args: [
            key: any,
            xx: 'XX',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, xx: 'XX', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, xx: 'XX', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            gt: 'GT',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', gt: 'GT', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            gt: 'GT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, xx: 'XX', gt: 'GT', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            gt: 'GT',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', gt: 'GT', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            gt: 'GT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (
        key: any,
        xx: 'XX',
        gt: 'GT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<string, Context>;
    (
        ...args: [
            key: any,
            xx: 'XX',
            lt: 'LT',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', lt: 'LT', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            lt: 'LT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (key: any, xx: 'XX', lt: 'LT', incr: 'INCR', ...scoreMembers: any[]): Result<
        string,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            lt: 'LT',
            ch: 'CH',
            ...scoreMembers: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, xx: 'XX', lt: 'LT', ch: 'CH', ...scoreMembers: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            lt: 'LT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<string>
        ]
    ): Result<string, Context>;
    (
        key: any,
        xx: 'XX',
        lt: 'LT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<string, 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

method zaddBuffer

zaddBuffer: {
    (
        ...args: [
            key: RedisKey,
            incr: 'INCR',
            ...scoreMembers: (string | Buffer | number)[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (key: any, incr: 'INCR', ...scoreMembers: any[]): Result<Buffer, Context>;
    (
        ...args: [
            key: any,
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (key: any, ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        Buffer,
        Context
    >;
    (
        ...args: [
            key: any,
            gt: 'GT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (key: any, gt: 'GT', incr: 'INCR', ...scoreMembers: any[]): Result<
        Buffer,
        Context
    >;
    (
        ...args: [
            key: any,
            gt: 'GT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (key: any, gt: 'GT', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        Buffer,
        Context
    >;
    (
        ...args: [
            key: any,
            lt: 'LT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (key: any, lt: 'LT', incr: 'INCR', ...scoreMembers: any[]): Result<
        Buffer,
        Context
    >;
    (
        ...args: [
            key: any,
            lt: 'LT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<Buffer>
        ]
    ): Result<Buffer, Context>;
    (key: any, lt: 'LT', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        Buffer,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, nx: 'NX', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, nx: 'NX', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            gt: 'GT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, nx: 'NX', gt: 'GT', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            gt: 'GT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (
        key: any,
        nx: 'NX',
        gt: 'GT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<any, Context>;
    (
        ...args: [
            key: any,
            nx: 'NX',
            lt: 'LT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, nx: 'NX', lt: 'LT', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            nx: 'NX',
            lt: 'LT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (
        key: any,
        nx: 'NX',
        lt: 'LT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<any, Context>;
    (
        ...args: [
            key: any,
            xx: 'XX',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, xx: 'XX', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, xx: 'XX', ch: 'CH', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            gt: 'GT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, xx: 'XX', gt: 'GT', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            gt: 'GT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (
        key: any,
        xx: 'XX',
        gt: 'GT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<any, Context>;
    (
        ...args: [
            key: any,
            xx: 'XX',
            lt: 'LT',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (key: any, xx: 'XX', lt: 'LT', incr: 'INCR', ...scoreMembers: any[]): Result<
        any,
        Context
    >;
    (
        ...args: [
            key: any,
            xx: 'XX',
            lt: 'LT',
            ch: 'CH',
            incr: 'INCR',
            ...scoreMembers: any[],
            callback: Callback<any>
        ]
    ): Result<any, Context>;
    (
        key: any,
        xx: 'XX',
        lt: 'LT',
        ch: 'CH',
        incr: 'INCR',
        ...scoreMembers: any[]
    ): Result<any, Context>;
};

method zcard

zcard: (key: RedisKey, callback?: Callback<number>) => Result<number, Context>;

Get the number of members in a sorted set - _group_: sorted-set - _complexity_: O(1) - _since_: 1.2.0

method zcount

zcount: (
    key: RedisKey,
    min: number | string,
    max: number | string,
    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

method zdiff

zdiff: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (numkeys: string | number, ...keys: any[]): Result<string[], Context>;
    (numkeys: string | number, keys: any[]): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (numkeys: string | number, keys: any[], withscores: 'WITHSCORES'): Result<
        string[],
        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

method zdiffBuffer

zdiffBuffer: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (numkeys: string | number, ...keys: any[]): Result<Buffer[], Context>;
    (numkeys: string | number, keys: any[]): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (numkeys: string | number, keys: any[], withscores: 'WITHSCORES'): Result<
        Buffer[],
        Context
    >;
};

method zdiffstore

zdiffstore: {
    (
        ...args: [
            destination: RedisKey,
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        callback: Callback<number>
    ): Result<number, Context>;
    (destination: any, numkeys: string | number, ...keys: any[]): Result<
        number,
        Context
    >;
    (destination: any, numkeys: string | number, keys: any[]): Result<
        number,
        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

method zincrby

zincrby: (
    key: RedisKey,
    increment: number | string,
    member: string | Buffer | number,
    callback?: Callback<string>
) => Result<string, 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

method zincrbyBuffer

zincrbyBuffer: (
    key: RedisKey,
    increment: number | string,
    member: string | Buffer | number,
    callback?: Callback<Buffer>
) => Result<Buffer, Context>;

method zinter

zinter: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (numkeys: string | number, ...keys: any[]): Result<string[], Context>;
    (numkeys: string | number, keys: any[]): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (numkeys: string | number, keys: any[], withscores: 'WITHSCORES'): Result<
        string[],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (numkeys: string | number, ...args: any[]): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], 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

method zinterBuffer

zinterBuffer: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (numkeys: string | number, ...keys: any[]): Result<Buffer[], Context>;
    (numkeys: string | number, keys: any[]): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (numkeys: string | number, keys: any[], withscores: 'WITHSCORES'): Result<
        Buffer[],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (numkeys: string | number, ...args: any[]): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
};

method zintercard

zintercard: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (numkeys: string | number, keys: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (numkeys: string | number, ...keys: any[]): Result<number, Context>;
    (numkeys: string | number, keys: any[]): Result<number, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            limitToken: 'LIMIT',
            limit: string | number,
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        numkeys: string | number,
        keys: any[],
        limitToken: 'LIMIT',
        limit: string | number,
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            limitToken: 'LIMIT',
            limit: string | number
        ]
    ): Result<number, Context>;
    (
        numkeys: string | number,
        keys: any[],
        limitToken: 'LIMIT',
        limit: string | number
    ): Result<number, 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

method zinterstore

zinterstore: {
    (
        ...args: [
            destination: RedisKey,
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        callback: Callback<number>
    ): Result<number, Context>;
    (destination: any, numkeys: string | number, ...keys: any[]): Result<
        number,
        Context
    >;
    (destination: any, numkeys: string | number, keys: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM'
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN'
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX'
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (destination: any, numkeys: string | number, ...args: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): 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

method zlexcount

zlexcount: (
    key: RedisKey,
    min: string | Buffer | number,
    max: string | Buffer | number,
    callback?: Callback<number>
) => 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

method zmpop

zmpop: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            min: 'MIN',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        numkeys: string | number,
        keys: any[],
        min: 'MIN',
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (...args: [numkeys: string | number, ...keys: any[], min: 'MIN']): Result<
        unknown,
        Context
    >;
    (numkeys: string | number, keys: any[], min: 'MIN'): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            min: 'MIN',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        numkeys: string | number,
        keys: any[],
        min: 'MIN',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            min: 'MIN',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<unknown, Context>;
    (
        numkeys: string | number,
        keys: any[],
        min: 'MIN',
        countToken: 'COUNT',
        count: string | number
    ): Result<unknown, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX',
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        numkeys: string | number,
        keys: any[],
        max: 'MAX',
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (...args: [numkeys: string | number, ...keys: any[], max: 'MAX']): Result<
        unknown,
        Context
    >;
    (numkeys: string | number, keys: any[], max: 'MAX'): Result<
        unknown,
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX',
            countToken: 'COUNT',
            count: string | number,
            callback: Callback<unknown>
        ]
    ): Result<unknown, Context>;
    (
        numkeys: string | number,
        keys: any[],
        max: 'MAX',
        countToken: 'COUNT',
        count: string | number,
        callback: Callback<unknown>
    ): Result<unknown, Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            max: 'MAX',
            countToken: 'COUNT',
            count: string | number
        ]
    ): Result<unknown, Context>;
    (
        numkeys: string | number,
        keys: any[],
        max: 'MAX',
        countToken: 'COUNT',
        count: string | number
    ): Result<unknown, 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

method zmscore

zmscore: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<(string | null)[]>
        ]
    ): Result<(string | null)[], Context>;
    (key: any, members: any[], callback: Callback<string[]>): Result<
        string[],
        Context
    >;
    (key: any, ...members: any[]): Result<string[], Context>;
    (key: any, members: any[]): Result<string[], 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

method zmscoreBuffer

zmscoreBuffer: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<(Buffer | null)[]>
        ]
    ): Result<(Buffer | null)[], Context>;
    (key: any, members: any[], callback: Callback<any[]>): Result<
        any[],
        Context
    >;
    (key: any, ...members: any[]): Result<any[], Context>;
    (key: any, members: any[]): Result<any[], Context>;
};

method zpopmax

zpopmax: {
    (key: RedisKey, callback?: Callback<string[]>): Result<string[], Context>;
    (key: any, count: string | number, callback?: Callback<string[]>): Result<
        string[],
        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

method zpopmaxBuffer

zpopmaxBuffer: {
    (key: RedisKey, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
};

method zpopmin

zpopmin: {
    (key: RedisKey, callback?: Callback<string[]>): Result<string[], Context>;
    (key: any, count: string | number, callback?: Callback<string[]>): Result<
        string[],
        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

method zpopminBuffer

zpopminBuffer: {
    (key: RedisKey, callback?: Callback<Buffer[]>): Result<Buffer[], Context>;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
};

method zrandmember

zrandmember: {
    (key: RedisKey, callback?: Callback<string | null>): Result<
        string | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<string[]>): Result<
        string[],
        Context
    >;
    (
        key: any,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrandmemberBuffer

zrandmemberBuffer: {
    (key: RedisKey, callback?: Callback<Buffer | null>): Result<
        Buffer | null,
        Context
    >;
    (key: any, count: string | number, callback?: Callback<Buffer[]>): Result<
        Buffer[],
        Context
    >;
    (
        key: any,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrange

zrange: {
    (
        key: RedisKey,
        min: string | Buffer | number,
        max: string | Buffer | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrangeBuffer

zrangeBuffer: {
    (
        key: RedisKey,
        min: string | Buffer | number,
        max: string | Buffer | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrangebylex

zrangebylex: {
    (
        key: RedisKey,
        min: string | Buffer | number,
        max: string | Buffer | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrangebylexBuffer

zrangebylexBuffer: {
    (
        key: RedisKey,
        min: string | Buffer | number,
        max: string | Buffer | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrangebyscore

zrangebyscore: {
    (
        key: RedisKey,
        min: number | string,
        max: number | string,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: string | number,
        max: string | number,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: string | number,
        max: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        min: string | number,
        max: string | number,
        withscores: 'WITHSCORES',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrangebyscoreBuffer

zrangebyscoreBuffer: {
    (
        key: RedisKey,
        min: number | string,
        max: number | string,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: string | number,
        max: string | number,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: string | number,
        max: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        min: string | number,
        max: string | number,
        withscores: 'WITHSCORES',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrangestore

zrangestore: {
    (
        dst: RedisKey,
        src: RedisKey,
        min: string | Buffer | number,
        max: string | Buffer | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        rev: 'REV',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        byscore: 'BYSCORE',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        callback?: Callback<number>
    ): Result<number, Context>;
    (
        dst: any,
        src: any,
        min: any,
        max: any,
        bylex: 'BYLEX',
        rev: 'REV',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<number>
    ): Result<number, 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

method zrank

zrank: (
    key: RedisKey,
    member: string | Buffer | number,
    callback?: Callback<number | null>
) => Result<number | null, Context>;

Determine the index of a member in a sorted set - _group_: sorted-set - _complexity_: O(log(N)) - _since_: 2.0.0

method zrem

zrem: {
    (
        ...args: [
            key: RedisKey,
            ...members: (string | Buffer | number)[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (key: any, members: any[], callback: Callback<number>): Result<
        number,
        Context
    >;
    (key: any, ...members: any[]): Result<number, Context>;
    (key: any, members: any[]): Result<number, 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

method zremrangebylex

zremrangebylex: (
    key: RedisKey,
    min: string | Buffer | number,
    max: string | Buffer | number,
    callback?: Callback<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

method zremrangebyrank

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

method zremrangebyscore

zremrangebyscore: (
    key: RedisKey,
    min: number | string,
    max: 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

method zrevrange

zrevrange: {
    (
        key: RedisKey,
        start: number | string,
        stop: number | string,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        start: string | number,
        stop: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrevrangeBuffer

zrevrangeBuffer: {
    (
        key: RedisKey,
        start: number | string,
        stop: number | string,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        start: string | number,
        stop: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrevrangebylex

zrevrangebylex: {
    (
        key: RedisKey,
        max: string | Buffer | number,
        min: string | Buffer | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        max: any,
        min: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrevrangebylexBuffer

zrevrangebylexBuffer: {
    (
        key: RedisKey,
        max: string | Buffer | number,
        min: string | Buffer | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        max: any,
        min: any,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrevrangebyscore

zrevrangebyscore: {
    (
        key: RedisKey,
        max: number | string,
        min: number | string,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        max: string | number,
        min: string | number,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        max: string | number,
        min: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<string[]>
    ): Result<string[], Context>;
    (
        key: any,
        max: string | number,
        min: string | number,
        withscores: 'WITHSCORES',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<string[]>
    ): Result<string[], 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

method zrevrangebyscoreBuffer

zrevrangebyscoreBuffer: {
    (
        key: RedisKey,
        max: number | string,
        min: number | string,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        max: string | number,
        min: string | number,
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        max: string | number,
        min: string | number,
        withscores: 'WITHSCORES',
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        key: any,
        max: string | number,
        min: string | number,
        withscores: 'WITHSCORES',
        offsetCountToken: 'LIMIT',
        offset: string | number,
        count: string | number,
        callback?: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
};

method zrevrank

zrevrank: (
    key: RedisKey,
    member: string | Buffer | number,
    callback?: Callback<number | null>
) => Result<number | null, 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

method zscan

zscan: {
    (
        key: RedisKey,
        cursor: number | string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: string, elements: string[]]>
    ): Result<[cursor: string, elements: string[]], 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

method zscanBuffer

zscanBuffer: {
    (
        key: RedisKey,
        cursor: number | string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
    (
        key: any,
        cursor: string | number,
        patternToken: 'MATCH',
        pattern: string,
        countToken: 'COUNT',
        count: string | number,
        callback?: Callback<[cursor: Buffer, elements: Buffer[]]>
    ): Result<[cursor: Buffer, elements: Buffer[]], Context>;
};

method zscore

zscore: (
    key: RedisKey,
    member: string | Buffer | number,
    callback?: Callback<string | null>
) => Result<string | null, Context>;

Get the score associated with the given member in a sorted set - _group_: sorted-set - _complexity_: O(1) - _since_: 1.2.0

method zscoreBuffer

zscoreBuffer: (
    key: RedisKey,
    member: string | Buffer | number,
    callback?: Callback<Buffer | null>
) => Result<Buffer | null, Context>;

method zunion

zunion: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (numkeys: string | number, ...keys: any[]): Result<string[], Context>;
    (numkeys: string | number, keys: any[]): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (numkeys: string | number, keys: any[], withscores: 'WITHSCORES'): Result<
        string[],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES',
        callback: Callback<string[]>
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES'
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (numkeys: string | number, ...args: any[]): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<string[]>
        ]
    ): Result<string[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<string[], 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

method zunionBuffer

zunionBuffer: {
    (
        ...args: [
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (numkeys: string | number, ...keys: any[]): Result<Buffer[], Context>;
    (numkeys: string | number, keys: any[]): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (numkeys: string | number, keys: any[], withscores: 'WITHSCORES'): Result<
        Buffer[],
        Context
    >;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        withscores: 'WITHSCORES'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        withscores: 'WITHSCORES'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES',
        callback: Callback<Buffer[]>
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        withscores: 'WITHSCORES'
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (numkeys: string | number, ...args: any[]): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES',
            callback: Callback<Buffer[]>
        ]
    ): Result<Buffer[], Context>;
    (
        ...args: [
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            withscores: 'WITHSCORES'
        ]
    ): Result<Buffer[], Context>;
};

method zunionstore

zunionstore: {
    (
        ...args: [
            destination: RedisKey,
            numkeys: number | string,
            ...keys: RedisKey[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        callback: Callback<number>
    ): Result<number, Context>;
    (destination: any, numkeys: string | number, ...keys: any[]): Result<
        number,
        Context
    >;
    (destination: any, numkeys: string | number, keys: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM',
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        sum: 'SUM'
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN',
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        min: 'MIN'
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX',
        callback: Callback<number>
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...keys: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<number, Context>;
    (
        destination: any,
        numkeys: string | number,
        keys: any[],
        aggregate: 'AGGREGATE',
        max: 'MAX'
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (destination: any, numkeys: string | number, ...args: any[]): Result<
        number,
        Context
    >;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            sum: 'SUM'
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            min: 'MIN'
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX',
            callback: Callback<number>
        ]
    ): Result<number, Context>;
    (
        ...args: [
            destination: any,
            numkeys: string | number,
            ...args: any[],
            aggregate: 'AGGREGATE',
            max: 'MAX'
        ]
    ): Result<number, 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

interface SentinelAddress

interface SentinelAddress {}

property family

family?: number;

property host

host: string;

property port

port: number;

interface SentinelConnectionOptions

interface SentinelConnectionOptions {}

property connectTimeout

connectTimeout?: number;

property disconnectTimeout

disconnectTimeout?: number;

property enableTLSForSentinelMode

enableTLSForSentinelMode?: boolean;

property failoverDetector

failoverDetector?: boolean;

property name

name?: string;

Master group name of the Sentinel

property natMap

natMap?: NatMap;

property preferredSlaves

preferredSlaves?: PreferredSlaves;

property role

role?: 'master' | 'slave';

"master"

property sentinelCommandTimeout

sentinelCommandTimeout?: number;

property sentinelMaxConnections

sentinelMaxConnections?: number;

property sentinelPassword

sentinelPassword?: string;

property sentinelReconnectStrategy

sentinelReconnectStrategy?: (retryAttempts: number) => number | void | null;

property sentinelRetryStrategy

sentinelRetryStrategy?: (retryAttempts: number) => number | void | null;

property sentinels

sentinels?: Array<Partial<SentinelAddress>>;

property sentinelTLS

sentinelTLS?: ConnectionOptions;

property sentinelUsername

sentinelUsername?: string;

property tls

tls?: ConnectionOptions;

property updateSentinels

updateSentinels?: boolean;

Type Aliases

type Callback

type Callback<T = any> = (err?: Error | null, result?: T) => void;

type ClientContext

type ClientContext = {
    type: keyof ResultTypes<unknown, unknown>;
};

type ClusterNode

type ClusterNode =
    | string
    | number
    | {
          host?: string | undefined;
          port?: number | undefined;
      };

type DNSLookupFunction

type DNSLookupFunction = (
    hostname: string,
    callback: (
        err: NodeJS.ErrnoException | null | undefined,
        address: string,
        family?: number
    ) => void
) => void;

type DNSResolveSrvFunction

type DNSResolveSrvFunction = (
    hostname: string,
    callback: (
        err: NodeJS.ErrnoException | null | undefined,
        records?: SrvRecord[]
    ) => void
) => void;

type NodeRole

type NodeRole = 'master' | 'slave' | 'all';

type RedisKey

type RedisKey = string | Buffer;

type RedisOptions

type RedisOptions = CommonRedisOptions &
    SentinelConnectionOptions &
    StandaloneConnectionOptions;

type RedisValue

type RedisValue = string | Buffer | number;

type Result

type Result<T, Context extends ClientContext> = ResultTypes<
    T,
    Context
>[Context['type']];

type StandaloneConnectionOptions

type StandaloneConnectionOptions = Partial<TcpOptions & IpcOptions> & {
    disconnectTimeout?: number;
    tls?: ConnectionOptions;
};

Package Files (16)

Dependencies (9)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ioredis.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ioredis)

HTML

<a href="https://www.jsdocs.io/package/ioredis"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 3 months ago.
Package analyzed in 16989 ms.
Missing or incorrect documentation? Open an issue for this package.

ioredis

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable ReplyError

Functions

function print

Classes

class AbstractConnector

property connecting

property firstError

property stream

method check

method connect

method disconnect

class Cluster

property autoPipelineQueueSize

property isCluster

property options

property slots

property status

method connect

method delayUntilReady

method disconnect

method duplicate

Example 1

method handleError

method hscanBufferStream

method hscanStream

method nodes

method quit

method refreshSlotsCache

method sendCommand

method sscanBufferStream

method sscanStream

method zscanBufferStream

method zscanStream

class Command

Parameter name

Parameter args

Parameter options

Parameter callback

property args

property FLAGS

property ignore

property inTransaction

property isReadOnly

property isResolved

property name

property pipelineIndex

property promise

property reject

property resolve

method checkFlag

method getKeys

method getSlot

method setArgumentTransformer

method setReplyTransformer

method setTimeout

method stringifyArguments

method toWritable

method transformReply

class Pipeline

property isCluster

property isPipeline

property leftRedirections

property promise

property redis

property reject

property resolve

method addBatch

method fillResult

method sendCommand

class Redis