ioredis

  • Version 5.4.1
  • Published
  • 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

Functions

Classes

Interfaces

Type Aliases

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: