@types/redis

  • Version 2.8.32
  • Published
  • 60.4 kB
  • 1 dependency
  • MIT license

Install

npm i @types/redis
yarn add @types/redis
pnpm add @types/redis

Overview

TypeScript definitions for redis

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable debug_mode

let debug_mode: boolean;

    variable Multi

    const Multi: new () => Multi;

      variable RedisClient

      const RedisClient: new (options: ClientOpts) => RedisClient;

        Functions

        function add_command

        add_command: (command: string) => void;

          function addCommand

          addCommand: (command: string) => void;

            function createClient

            createClient: {
            (port: number, host?: string, options?: ClientOpts): RedisClient;
            (unix_socket: string, options?: ClientOpts): RedisClient;
            (redis_url: string, options?: ClientOpts): RedisClient;
            (options?: ClientOpts): RedisClient;
            };

              function print

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

                Classes

                class AbortError

                class AbortError extends RedisError {}

                  property args

                  args?: unknown[];

                    property code

                    code?: string;

                      property command

                      command: string;

                        class AggregateError

                        class AggregateError extends AbortError {}

                          class ParserError

                          class ParserError extends RedisError {}

                            property buffer

                            buffer: any;

                              property offset

                              offset: number;

                                class RedisError

                                class RedisError extends Error {}

                                  property name

                                  name: string;

                                    class ReplyError

                                    class ReplyError extends RedisError {}

                                      property args

                                      args?: unknown[];

                                        property code

                                        code: string;

                                          property command

                                          command: string;

                                            Interfaces

                                            interface ClientOpts

                                            interface ClientOpts {}
                                            • Client options.

                                              See Also

                                              • https://github.com/NodeRedis/node-redis#user-content-options-object-properties

                                            property auth_pass

                                            auth_pass?: string | undefined;

                                              property connect_timeout

                                              connect_timeout?: number | undefined;

                                                property db

                                                db?: string | number | undefined;
                                                • If set, client will run Redis **select** command on connect. null

                                                property detect_buffers

                                                detect_buffers?: boolean | undefined;
                                                • If set to true, then replies will be sent to callbacks as Buffers. This option lets you switch between Buffers and Strings on a per-command basis, whereas return_buffers applies to every command on a client.\ **Note**: This doesn't work properly with the pubsub mode. A subscriber has to either always return Strings or Buffers. false

                                                property disable_resubscribing

                                                disable_resubscribing?: boolean | undefined;
                                                • If set to true, a client won't resubscribe after disconnecting. false

                                                property enable_offline_queue

                                                enable_offline_queue?: boolean | undefined;
                                                • By default, if there is no active connection to the Redis server, commands are added to a queue and are executed once the connection has been established. Setting enable_offline_queue to false will disable this feature and the callback will be executed immediately with an error, or an error will be emitted if no callback is specified. true

                                                property family

                                                family?: string | undefined;
                                                • You can force using IPv6 if you set the family to **IPv6**.

                                                  See Also

                                                  • Node.js [net](https://nodejs.org/api/net.html) or [dns](https://nodejs.org/api/dns.html) modules on how to use the family type. IPv4

                                                property host

                                                host?: string | undefined;
                                                • IP address of the Redis server. 127.0.0.1

                                                property max_attempts

                                                max_attempts?: number | undefined;

                                                  property no_ready_check

                                                  no_ready_check?: boolean | undefined;
                                                  • When a connection is established to the Redis server, the server might still be loading the database from disk. While loading, the server will not respond to any commands. To work around this, Node Redis has a "ready check" which sends the **INFO** command to the server. The response from the **INFO** command indicates whether the server is ready for more commands. When ready, **node_redis** emits a **ready** event. Setting no_ready_check to true will inhibit this check. false

                                                  property parser

                                                  parser?: string | undefined;

                                                    property password

                                                    password?: string | undefined;
                                                    • If set, client will run Redis auth command on connect. Alias auth_pass.\ **Note**: Node Redis < 2.5 must use auth_pass. null

                                                    property path

                                                    path?: string | undefined;
                                                    • The UNIX socket string of the Redis server. null

                                                    property port

                                                    port?: number | undefined;
                                                    • Port of the Redis server. 6379

                                                    property prefix

                                                    prefix?: string | undefined;
                                                    • A string used to prefix all used keys (e.g. namespace:test). Please be aware that the **keys** command will not be prefixed. The **keys** command has a "pattern" as argument and no key and it would be impossible to determine the existing keys in Redis if this would be prefixed. null

                                                    property rename_commands

                                                    rename_commands?: { [command: string]: string } | null | undefined;
                                                    • Passing an object with renamed commands to use instead of the original functions. For example, if you renamed the command **KEYS** to "DO-NOT-USE" then the rename_commands object would be: { KEYS : "DO-NOT-USE" }.

                                                      See Also

                                                      • the [Redis security topics](http://redis.io/topics/security) for more info. null

                                                    property retry_max_delay

                                                    retry_max_delay?: number | undefined;

                                                      property retry_strategy

                                                      retry_strategy?: RetryStrategy | undefined;
                                                      • A function that receives an options object as parameter including the retry attempt, the total_retry_time indicating how much time passed since the last time connected, the **error** why the connection was lost and the number of times_connected in total. If you return a number from this function, the retry will happen after that time in milliseconds. If you return a non-number, no further retry will happen and all offline commands are flushed with errors. Return an error to return that specific error to all offline commands. function

                                                        Example 1

                                                        const client = redis.createClient({ retry_strategy: function(options) { if (options.error && options.error.code === "ECONNREFUSED") { // End reconnecting on a specific error and flush all commands with // a individual error return new Error("The server refused the connection"); } if (options.total_retry_time > 1000 * 60 * 60) { // End reconnecting after a specific timeout and flush all commands // with a individual error return new Error("Retry time exhausted"); } if (options.attempt > 10) { // End reconnecting with built in error return undefined; } // reconnect after return Math.min(options.attempt * 100, 3000); } });

                                                        See Also

                                                        • interface RetryStrategyOptions

                                                      property retry_unfulfilled_commands

                                                      retry_unfulfilled_commands?: boolean | undefined;
                                                      • If set to true, all commands that were unfulfilled while the connection is lost will be retried after the connection has been reestablished. Use this with caution if you use state altering commands (e.g. incr). This is especially useful if you use blocking commands. false

                                                      property return_buffers

                                                      return_buffers?: boolean | undefined;
                                                      • If set to true, then all replies will be sent to callbacks as Buffers instead of Strings. false

                                                      property socket_initial_delay

                                                      socket_initial_delay?: number | undefined;
                                                      • Initial Delay in milliseconds. This will also set the initial delay for keep-alive packets being sent to Redis. 0

                                                      property socket_keepalive

                                                      socket_keepalive?: boolean | undefined;
                                                      • If set to true, the keep-alive functionality is enabled on the underlying socket. true

                                                      property string_numbers

                                                      string_numbers?: boolean | undefined;
                                                      • Set to true, Node Redis will return Redis number values as Strings instead of javascript Numbers. Useful if you need to handle big numbers (above Number.MAX_SAFE_INTEGER === 2^53). Hiredis is incapable of this behavior, so setting this option to true will result in the built-in javascript parser being used no matter the value of the parser option. null

                                                      property tls

                                                      tls?: any;
                                                      • An object containing options to pass to [tls.connect](https://nodejs.org/api/tls.html#tls_tls_connect_port_host_options_callback) to set up a TLS connection to Redis (if, for example, it is set up to be accessible via a tunnel). null

                                                      property url

                                                      url?: string | undefined;
                                                      • The URL of the Redis server.\ Format: [redis[s]:]//[[user][:password@]][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]]\ More info avaliable at [IANA](http://www.iana.org/assignments/uri-schemes/prov/redis). null

                                                      interface Commands

                                                      interface Commands<R> {}

                                                        property bitfield

                                                        bitfield: OverloadedKeyCommand<string | number, number[], R>;
                                                        • Perform arbitrary bitfield integer operations on strings.

                                                        property BITFIELD

                                                        BITFIELD: OverloadedKeyCommand<string | number, number[], R>;

                                                          property blpop

                                                          blpop: OverloadedLastCommand<string, number, [string, string], R>;
                                                          • Remove and get the first element in a list, or block until one is available.

                                                          property BLPOP

                                                          BLPOP: OverloadedLastCommand<string, number, [string, string], R>;

                                                            property brpop

                                                            brpop: OverloadedLastCommand<string, number, [string, string], R>;
                                                            • Remove and get the last element in a list, or block until one is available.

                                                            property BRPOP

                                                            BRPOP: OverloadedLastCommand<string, number, [string, string], R>;

                                                              property client

                                                              client: OverloadedCommand<string, any, R>;
                                                              • KILL - Kill the connection of a client. LIST - Get the list of client connections. GETNAME - Get the current connection name. PAUSE - Stop processing commands from clients for some time. REPLY - Instruct the server whether to reply to commands. SETNAME - Set the current connection name.

                                                              property CLIENT

                                                              CLIENT: OverloadedCommand<string, any, R>;

                                                                property cluster

                                                                cluster: OverloadedCommand<string, any, this>;
                                                                • ADDSLOTS - Assign new hash slots to receiving node. COUNT-FAILURE-REPORTS - Return the number of failure reports active for a given node. COUNTKEYSINSLOT - Return the number of local keys in the specified hash slot. DELSLOTS - Set hash slots as unbound in receiving node. FAILOVER - Forces a slave to perform a manual failover of its master. FORGET - Remove a node from the nodes table. GETKEYSINSLOT - Return local key names in the specified hash slot. INFO - Provides info about Redis Cluster node state. KEYSLOT - Returns the hash slot of the specified key. MEET - Force a node cluster to handshake with another node. NODES - Get cluster config for the node. REPLICATE - Reconfigure a node as a slave of the specified master node. RESET - Reset a Redis Cluster node. SAVECONFIG - Forces the node to save cluster state on disk. SET-CONFIG-EPOCH - Set the configuration epoch in a new node. SETSLOT - Bind a hash slot to a specified node. SLAVES - List slave nodes of the specified master node. SLOTS - Get array of Cluster slot to node mappings.

                                                                property CLUSTER

                                                                CLUSTER: OverloadedCommand<string, any, this>;

                                                                  property config

                                                                  config: OverloadedCommand<string, boolean, R>;
                                                                  • Get array of Redis command details.

                                                                    COUNT - Get array of Redis command details. GETKEYS - Extract keys given a full Redis command. INFO - Get array of specific Redis command details. GET - Get the value of a configuration parameter. REWRITE - Rewrite the configuration file with the in memory configuration. SET - Set a configuration parameter to the given value. RESETSTAT - Reset the stats returned by INFO.

                                                                  property CONFIG

                                                                  CONFIG: OverloadedCommand<string, boolean, R>;

                                                                    property debug

                                                                    debug: OverloadedCommand<string, boolean, R>;
                                                                    • OBJECT - Get debugging information about a key. SEGFAULT - Make the server crash.

                                                                    property DEBUG

                                                                    DEBUG: OverloadedCommand<string, boolean, R>;

                                                                      property del

                                                                      del: OverloadedCommand<string, number, R>;
                                                                      • Delete a key.

                                                                      property DEL

                                                                      DEL: OverloadedCommand<string, number, R>;

                                                                        property eval

                                                                        eval: OverloadedCommand<string | number, any, R>;
                                                                        • Execute a Lua script server side.

                                                                        property EVAL

                                                                        EVAL: OverloadedCommand<string | number, any, R>;

                                                                          property evalsha

                                                                          evalsha: OverloadedCommand<string | number, any, R>;
                                                                          • Execute a Lue script server side.

                                                                          property EVALSHA

                                                                          EVALSHA: OverloadedCommand<string | number, any, R>;

                                                                            property exists

                                                                            exists: OverloadedCommand<string, number, R>;
                                                                            • Determine if a key exists.

                                                                            property EXISTS

                                                                            EXISTS: OverloadedCommand<string, number, R>;

                                                                              property geoadd

                                                                              geoadd: OverloadedKeyCommand<string | number, number, R>;
                                                                              • Add one or more geospatial items in the geospatial index represented using a sorted set.

                                                                              property GEOADD

                                                                              GEOADD: OverloadedKeyCommand<string | number, number, R>;

                                                                                property geodist

                                                                                geodist: OverloadedKeyCommand<string, string, R>;
                                                                                • Returns the distance between two members of a geospatial index.

                                                                                property GEODIST

                                                                                GEODIST: OverloadedKeyCommand<string, string, R>;

                                                                                  property geohash

                                                                                  geohash: OverloadedKeyCommand<string, string, R>;
                                                                                  • Returns members of a geospatial index as standard geohash strings.

                                                                                  property GEOHASH

                                                                                  GEOHASH: OverloadedKeyCommand<string, string, R>;

                                                                                    property geopos

                                                                                    geopos: OverloadedKeyCommand<string, Array<[number, number]>, R>;
                                                                                    • Returns longitude and latitude of members of a geospatial index.

                                                                                    property GEOPOS

                                                                                    GEOPOS: OverloadedKeyCommand<string, Array<[number, number]>, R>;

                                                                                      property georadius

                                                                                      georadius: OverloadedKeyCommand<
                                                                                      string | number,
                                                                                      Array<string | [string, string | [string, string]]>,
                                                                                      R
                                                                                      >;
                                                                                      • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.

                                                                                      property GEORADIUS

                                                                                      GEORADIUS: OverloadedKeyCommand<
                                                                                      string | number,
                                                                                      Array<string | [string, string | [string, string]]>,
                                                                                      R
                                                                                      >;

                                                                                        property georadiusbymember

                                                                                        georadiusbymember: OverloadedKeyCommand<
                                                                                        string | number,
                                                                                        Array<string | [string, string | [string, string]]>,
                                                                                        R
                                                                                        >;
                                                                                        • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.

                                                                                        property GEORADIUSBYMEMBER

                                                                                        GEORADIUSBYMEMBER: OverloadedKeyCommand<
                                                                                        string | number,
                                                                                        Array<string | [string, string | [string, string]]>,
                                                                                        R
                                                                                        >;

                                                                                          property hdel

                                                                                          hdel: OverloadedKeyCommand<string, number, R>;
                                                                                          • Delete on or more hash fields.

                                                                                          property HDEL

                                                                                          HDEL: OverloadedKeyCommand<string, number, R>;

                                                                                            property hmget

                                                                                            hmget: OverloadedKeyCommand<string, string[], R>;
                                                                                            • Get the values of all the given hash fields.

                                                                                            property HMGET

                                                                                            HMGET: OverloadedKeyCommand<string, string[], R>;

                                                                                              property hmset

                                                                                              hmset: OverloadedSetCommand<string | number, 'OK', R>;
                                                                                              • Set multiple hash fields to multiple values.

                                                                                              property HMSET

                                                                                              HMSET: OverloadedSetCommand<string | number, 'OK', R>;

                                                                                                property hscan

                                                                                                hscan: OverloadedKeyCommand<string, [string, string[]], R>;
                                                                                                • Incrementally iterate hash fields and associated values.

                                                                                                property HSCAN

                                                                                                HSCAN: OverloadedKeyCommand<string, [string, string[]], R>;

                                                                                                  property hset

                                                                                                  hset: OverloadedSetCommand<string, number, R>;
                                                                                                  • Set the string value of a hash field.

                                                                                                  property HSET

                                                                                                  HSET: OverloadedSetCommand<string, number, R>;

                                                                                                    property lpush

                                                                                                    lpush: OverloadedKeyCommand<string, number, R>;
                                                                                                    • Prepend one or multiple values to a list.

                                                                                                    property LPUSH

                                                                                                    LPUSH: OverloadedKeyCommand<string, number, R>;

                                                                                                      property mget

                                                                                                      mget: OverloadedCommand<string, string[], R>;
                                                                                                      • Get the values of all given keys.

                                                                                                      property MGET

                                                                                                      MGET: OverloadedCommand<string, string[], R>;

                                                                                                        property migrate

                                                                                                        migrate: OverloadedCommand<string, boolean, R>;
                                                                                                        • Atomically tranfer a key from a Redis instance to another one.

                                                                                                        property MIGRATE

                                                                                                        MIGRATE: OverloadedCommand<string, boolean, R>;

                                                                                                          property mset

                                                                                                          mset: OverloadedCommand<string, boolean, R>;
                                                                                                          • Set multiple keys to multiple values.

                                                                                                          property MSET

                                                                                                          MSET: OverloadedCommand<string, boolean, R>;

                                                                                                            property msetnx

                                                                                                            msetnx: OverloadedCommand<string, boolean, R>;
                                                                                                            • Set multiple keys to multiple values, only if none of the keys exist.

                                                                                                            property MSETNX

                                                                                                            MSETNX: OverloadedCommand<string, boolean, R>;

                                                                                                              property object

                                                                                                              object: OverloadedCommand<string, any, R>;
                                                                                                              • Inspect the internals of Redis objects.

                                                                                                              property OBJECT

                                                                                                              OBJECT: OverloadedCommand<string, any, R>;

                                                                                                                property pfadd

                                                                                                                pfadd: OverloadedKeyCommand<string, number, R>;
                                                                                                                • Adds the specified elements to the specified HyperLogLog.

                                                                                                                property PFADD

                                                                                                                PFADD: OverloadedKeyCommand<string, number, R>;

                                                                                                                  property pfcount

                                                                                                                  pfcount: OverloadedCommand<string, number, R>;
                                                                                                                  • Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

                                                                                                                  property PFCOUNT

                                                                                                                  PFCOUNT: OverloadedCommand<string, number, R>;

                                                                                                                    property pfmerge

                                                                                                                    pfmerge: OverloadedCommand<string, boolean, R>;
                                                                                                                    • Merge N different HyperLogLogs into a single one.

                                                                                                                    property PFMERGE

                                                                                                                    PFMERGE: OverloadedCommand<string, boolean, R>;

                                                                                                                      property psubscribe

                                                                                                                      psubscribe: OverloadedListCommand<string, string, R>;
                                                                                                                      • Listen for messages published to channels matching the given patterns.

                                                                                                                      property PSUBSCRIBE

                                                                                                                      PSUBSCRIBE: OverloadedListCommand<string, string, R>;

                                                                                                                        property pubsub

                                                                                                                        pubsub: OverloadedCommand<string, number, R>;
                                                                                                                        • Inspect the state of the Pub/Sub subsytem.

                                                                                                                        property PUBSUB

                                                                                                                        PUBSUB: OverloadedCommand<string, number, R>;

                                                                                                                          property punsubscribe

                                                                                                                          punsubscribe: OverloadedListCommand<string, string, R>;
                                                                                                                          • Stop listening for messages posted to channels matching the given patterns.

                                                                                                                          property PUNSUBSCRIBE

                                                                                                                          PUNSUBSCRIBE: OverloadedListCommand<string, string, R>;

                                                                                                                            property rpush

                                                                                                                            rpush: OverloadedKeyCommand<string, number, R>;
                                                                                                                            • Append one or multiple values to a list.

                                                                                                                            property RPUSH

                                                                                                                            RPUSH: OverloadedKeyCommand<string, number, R>;

                                                                                                                              property sadd

                                                                                                                              sadd: OverloadedKeyCommand<string, number, R>;
                                                                                                                              • Append one or multiple members to a set.

                                                                                                                              property SADD

                                                                                                                              SADD: OverloadedKeyCommand<string, number, R>;

                                                                                                                                property scan

                                                                                                                                scan: OverloadedCommand<string, [string, string[]], R>;
                                                                                                                                • Incrementally iterate the keys space.

                                                                                                                                property SCAN

                                                                                                                                SCAN: OverloadedCommand<string, [string, string[]], R>;

                                                                                                                                  property script

                                                                                                                                  script: OverloadedCommand<string, any, R>;
                                                                                                                                  • DEBUG - Set the debug mode for executed scripts. EXISTS - Check existence of scripts in the script cache. FLUSH - Remove all scripts from the script cache. KILL - Kill the script currently in execution. LOAD - Load the specified Lua script into the script cache.

                                                                                                                                  property SCRIPT

                                                                                                                                  SCRIPT: OverloadedCommand<string, any, R>;

                                                                                                                                    property sdiff

                                                                                                                                    sdiff: OverloadedCommand<string, string[], R>;
                                                                                                                                    • Subtract multiple sets.

                                                                                                                                    property SDIFF

                                                                                                                                    SDIFF: OverloadedCommand<string, string[], R>;

                                                                                                                                      property sdiffstore

                                                                                                                                      sdiffstore: OverloadedKeyCommand<string, number, R>;
                                                                                                                                      • Subtract multiple sets and store the resulting set in a key.

                                                                                                                                      property SDIFFSTORE

                                                                                                                                      SDIFFSTORE: OverloadedKeyCommand<string, number, R>;

                                                                                                                                        property shutdown

                                                                                                                                        shutdown: OverloadedCommand<string, string, R>;
                                                                                                                                        • Synchronously save the dataset to disk and then shut down the server.

                                                                                                                                        property SHUTDOWN

                                                                                                                                        SHUTDOWN: OverloadedCommand<string, string, R>;

                                                                                                                                          property sinter

                                                                                                                                          sinter: OverloadedKeyCommand<string, string[], R>;
                                                                                                                                          • Intersect multiple sets.

                                                                                                                                          property SINTER

                                                                                                                                          SINTER: OverloadedKeyCommand<string, string[], R>;

                                                                                                                                            property sinterstore

                                                                                                                                            sinterstore: OverloadedCommand<string, number, R>;
                                                                                                                                            • Intersect multiple sets and store the resulting set in a key.

                                                                                                                                            property SINTERSTORE

                                                                                                                                            SINTERSTORE: OverloadedCommand<string, number, R>;

                                                                                                                                              property slowlog

                                                                                                                                              slowlog: OverloadedCommand<string, Array<[number, number, number, string[]]>, R>;
                                                                                                                                              • Manages the Redis slow queries log.

                                                                                                                                              property SLOWLOG

                                                                                                                                              SLOWLOG: OverloadedCommand<string, Array<[number, number, number, string[]]>, R>;

                                                                                                                                                property sort

                                                                                                                                                sort: OverloadedCommand<string, string[], R>;
                                                                                                                                                • Sort the elements in a list, set or sorted set.

                                                                                                                                                property SORT

                                                                                                                                                SORT: OverloadedCommand<string, string[], R>;

                                                                                                                                                  property srem

                                                                                                                                                  srem: OverloadedKeyCommand<string, number, R>;
                                                                                                                                                  • Remove one or more members from a set.

                                                                                                                                                  property SREM

                                                                                                                                                  SREM: OverloadedKeyCommand<string, number, R>;

                                                                                                                                                    property sscan

                                                                                                                                                    sscan: OverloadedKeyCommand<string, [string, string[]], R>;
                                                                                                                                                    • Incrementally iterate Set elements.

                                                                                                                                                    property SSCAN

                                                                                                                                                    SSCAN: OverloadedKeyCommand<string, [string, string[]], R>;

                                                                                                                                                      property subscribe

                                                                                                                                                      subscribe: OverloadedListCommand<string, string, R>;
                                                                                                                                                      • Listen for messages published to the given channels.

                                                                                                                                                      property SUBSCRIBE

                                                                                                                                                      SUBSCRIBE: OverloadedListCommand<string, string, R>;

                                                                                                                                                        property sunion

                                                                                                                                                        sunion: OverloadedCommand<string, string[], R>;
                                                                                                                                                        • Add multiple sets.

                                                                                                                                                        property SUNION

                                                                                                                                                        SUNION: OverloadedCommand<string, string[], R>;

                                                                                                                                                          property sunionstore

                                                                                                                                                          sunionstore: OverloadedCommand<string, number, R>;
                                                                                                                                                          • Add multiple sets and store the resulting set in a key.

                                                                                                                                                          property SUNIONSTORE

                                                                                                                                                          SUNIONSTORE: OverloadedCommand<string, number, R>;
                                                                                                                                                            unlink: OverloadedCommand<string, number, R>;
                                                                                                                                                            • Deletes a key in a non-blocking manner. Very similar to DEL, but actual memory reclamation happens in a different thread, making this non-blocking.

                                                                                                                                                            UNLINK: OverloadedCommand<string, number, R>;

                                                                                                                                                              property unsubscribe

                                                                                                                                                              unsubscribe: OverloadedListCommand<string, string, R>;
                                                                                                                                                              • Stop listening for messages posted to the given channels.

                                                                                                                                                              property UNSUBSCRIBE

                                                                                                                                                              UNSUBSCRIBE: OverloadedListCommand<string, string, R>;

                                                                                                                                                                property watch

                                                                                                                                                                watch: OverloadedCommand<string, 'OK', R>;
                                                                                                                                                                • Watch the given keys to determine execution of the MULTI/EXEC block.

                                                                                                                                                                property WATCH

                                                                                                                                                                WATCH: OverloadedCommand<string, 'OK', R>;

                                                                                                                                                                  property zadd

                                                                                                                                                                  zadd: OverloadedKeyCommand<string | number, number, R>;
                                                                                                                                                                  • Add one or more members to a sorted set, or update its score if it already exists.

                                                                                                                                                                  property ZADD

                                                                                                                                                                  ZADD: OverloadedKeyCommand<string | number, number, R>;

                                                                                                                                                                    property zinterstore

                                                                                                                                                                    zinterstore: OverloadedCommand<string | number, number, R>;
                                                                                                                                                                    • Intersect multiple sorted sets and store the resulting sorted set in a new key.

                                                                                                                                                                    property ZINTERSTORE

                                                                                                                                                                    ZINTERSTORE: OverloadedCommand<string | number, number, R>;

                                                                                                                                                                      property zrem

                                                                                                                                                                      zrem: OverloadedKeyCommand<string, number, R>;
                                                                                                                                                                      • Remove one or more members from a sorted set.

                                                                                                                                                                      property ZREM

                                                                                                                                                                      ZREM: OverloadedKeyCommand<string, number, R>;

                                                                                                                                                                        property zscan

                                                                                                                                                                        zscan: OverloadedKeyCommand<string, [string, string[]], R>;
                                                                                                                                                                        • Incrementally iterate sorted sets elements and associated scores.

                                                                                                                                                                        property ZSCAN

                                                                                                                                                                        ZSCAN: OverloadedKeyCommand<string, [string, string[]], R>;

                                                                                                                                                                          property zunionstore

                                                                                                                                                                          zunionstore: OverloadedCommand<string | number, number, R>;
                                                                                                                                                                          • Add multiple sorted sets and store the resulting sorted set in a new key.

                                                                                                                                                                          property ZUNIONSTORE

                                                                                                                                                                          ZUNIONSTORE: OverloadedCommand<string | number, number, R>;

                                                                                                                                                                            method append

                                                                                                                                                                            append: (key: string, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                            • Append a value to a key.

                                                                                                                                                                            method APPEND

                                                                                                                                                                            APPEND: (key: string, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                              method auth

                                                                                                                                                                              auth: (password: string, callback?: Callback<string>) => R;
                                                                                                                                                                              • Authenticate to the server.

                                                                                                                                                                              method AUTH

                                                                                                                                                                              AUTH: (password: string, callback?: Callback<string>) => R;

                                                                                                                                                                                method bgrewriteaof

                                                                                                                                                                                bgrewriteaof: (cb?: Callback<'OK'>) => R;
                                                                                                                                                                                • Asynchronously rewrite the append-only file.

                                                                                                                                                                                method BGREWRITEAOF

                                                                                                                                                                                BGREWRITEAOF: (cb?: Callback<'OK'>) => R;

                                                                                                                                                                                  method bgsave

                                                                                                                                                                                  bgsave: (cb?: Callback<string>) => R;
                                                                                                                                                                                  • Asynchronously save the dataset to disk.

                                                                                                                                                                                  method BGSAVE

                                                                                                                                                                                  BGSAVE: (cb?: Callback<string>) => R;

                                                                                                                                                                                    method bitcount

                                                                                                                                                                                    bitcount: {
                                                                                                                                                                                    (key: string, cb?: Callback<number>): R;
                                                                                                                                                                                    (key: string, start: number, end: number, cb?: Callback<number>): R;
                                                                                                                                                                                    };
                                                                                                                                                                                    • Count set bits in a string.

                                                                                                                                                                                    method BITCOUNT

                                                                                                                                                                                    BITCOUNT: {
                                                                                                                                                                                    (key: string, cb?: Callback<number>): R;
                                                                                                                                                                                    (key: string, start: number, end: number, cb?: Callback<number>): R;
                                                                                                                                                                                    };

                                                                                                                                                                                      method bitop

                                                                                                                                                                                      bitop: {
                                                                                                                                                                                      (
                                                                                                                                                                                      operation: string,
                                                                                                                                                                                      destkey: string,
                                                                                                                                                                                      key1: string,
                                                                                                                                                                                      key2: string,
                                                                                                                                                                                      key3: string,
                                                                                                                                                                                      cb?: Callback<number>
                                                                                                                                                                                      ): R;
                                                                                                                                                                                      (
                                                                                                                                                                                      operation: string,
                                                                                                                                                                                      destkey: string,
                                                                                                                                                                                      key1: string,
                                                                                                                                                                                      key2: string,
                                                                                                                                                                                      cb?: Callback<number>
                                                                                                                                                                                      ): R;
                                                                                                                                                                                      (operation: string, destkey: string, key: string, cb?: Callback<number>): R;
                                                                                                                                                                                      (
                                                                                                                                                                                      operation: string,
                                                                                                                                                                                      destkey: string,
                                                                                                                                                                                      ...args: (string | Callback<number>)[]
                                                                                                                                                                                      ): R;
                                                                                                                                                                                      };
                                                                                                                                                                                      • Perform bitwise operations between strings.

                                                                                                                                                                                      method BITOP

                                                                                                                                                                                      BITOP: {
                                                                                                                                                                                      (
                                                                                                                                                                                      operation: string,
                                                                                                                                                                                      destkey: string,
                                                                                                                                                                                      key1: string,
                                                                                                                                                                                      key2: string,
                                                                                                                                                                                      key3: string,
                                                                                                                                                                                      cb?: Callback<number>
                                                                                                                                                                                      ): R;
                                                                                                                                                                                      (
                                                                                                                                                                                      operation: string,
                                                                                                                                                                                      destkey: string,
                                                                                                                                                                                      key1: string,
                                                                                                                                                                                      key2: string,
                                                                                                                                                                                      cb?: Callback<number>
                                                                                                                                                                                      ): R;
                                                                                                                                                                                      (operation: string, destkey: string, key: string, cb?: Callback<number>): R;
                                                                                                                                                                                      (
                                                                                                                                                                                      operation: string,
                                                                                                                                                                                      destkey: string,
                                                                                                                                                                                      ...args: (string | Callback<number>)[]
                                                                                                                                                                                      ): R;
                                                                                                                                                                                      };

                                                                                                                                                                                        method bitpos

                                                                                                                                                                                        bitpos: {
                                                                                                                                                                                        (
                                                                                                                                                                                        key: string,
                                                                                                                                                                                        bit: number,
                                                                                                                                                                                        start: number,
                                                                                                                                                                                        end: number,
                                                                                                                                                                                        cb?: Callback<number>
                                                                                                                                                                                        ): R;
                                                                                                                                                                                        (key: string, bit: number, start: number, cb?: Callback<number>): R;
                                                                                                                                                                                        (key: string, bit: number, cb?: Callback<number>): R;
                                                                                                                                                                                        };
                                                                                                                                                                                        • Find first bit set or clear in a string.

                                                                                                                                                                                        method BITPOS

                                                                                                                                                                                        BITPOS: {
                                                                                                                                                                                        (
                                                                                                                                                                                        key: string,
                                                                                                                                                                                        bit: number,
                                                                                                                                                                                        start: number,
                                                                                                                                                                                        end: number,
                                                                                                                                                                                        cb?: Callback<number>
                                                                                                                                                                                        ): R;
                                                                                                                                                                                        (key: string, bit: number, start: number, cb?: Callback<number>): R;
                                                                                                                                                                                        (key: string, bit: number, cb?: Callback<number>): R;
                                                                                                                                                                                        };

                                                                                                                                                                                          method brpoplpush

                                                                                                                                                                                          brpoplpush: (
                                                                                                                                                                                          source: string,
                                                                                                                                                                                          destination: string,
                                                                                                                                                                                          timeout: number,
                                                                                                                                                                                          cb?: Callback<string | null>
                                                                                                                                                                                          ) => R;
                                                                                                                                                                                          • Pop a value from a list, push it to another list and return it; or block until one is available.

                                                                                                                                                                                          method BRPOPLPUSH

                                                                                                                                                                                          BRPOPLPUSH: (
                                                                                                                                                                                          source: string,
                                                                                                                                                                                          destination: string,
                                                                                                                                                                                          timeout: number,
                                                                                                                                                                                          cb?: Callback<string | null>
                                                                                                                                                                                          ) => R;

                                                                                                                                                                                            method command

                                                                                                                                                                                            command: (
                                                                                                                                                                                            cb?: Callback<Array<[string, number, string[], number, number, number]>>
                                                                                                                                                                                            ) => R;
                                                                                                                                                                                            • Get array of Redis command details.

                                                                                                                                                                                              COUNT - Get total number of Redis commands. GETKEYS - Extract keys given a full Redis command. INFO - Get array of specific REdis command details.

                                                                                                                                                                                            method COMMAND

                                                                                                                                                                                            COMMAND: (
                                                                                                                                                                                            cb?: Callback<Array<[string, number, string[], number, number, number]>>
                                                                                                                                                                                            ) => R;

                                                                                                                                                                                              method dbsize

                                                                                                                                                                                              dbsize: (cb?: Callback<number>) => R;
                                                                                                                                                                                              • Return the number of keys in the selected database.

                                                                                                                                                                                              method DBSIZE

                                                                                                                                                                                              DBSIZE: (cb?: Callback<number>) => R;

                                                                                                                                                                                                method decr

                                                                                                                                                                                                decr: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                • Decrement the integer value of a key by one.

                                                                                                                                                                                                method DECR

                                                                                                                                                                                                DECR: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                  method decrby

                                                                                                                                                                                                  decrby: (key: string, decrement: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                  • Decrement the integer value of a key by the given number.

                                                                                                                                                                                                  method DECRBY

                                                                                                                                                                                                  DECRBY: (key: string, decrement: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                    method discard

                                                                                                                                                                                                    discard: (cb?: Callback<'OK'>) => R;
                                                                                                                                                                                                    • Discard all commands issued after MULTI.

                                                                                                                                                                                                    method DISCARD

                                                                                                                                                                                                    DISCARD: (cb?: Callback<'OK'>) => R;

                                                                                                                                                                                                      method dump

                                                                                                                                                                                                      dump: (key: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                      • Return a serialized version of the value stored at the specified key.

                                                                                                                                                                                                      method DUMP

                                                                                                                                                                                                      DUMP: (key: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                        method echo

                                                                                                                                                                                                        echo: <T extends string>(message: T, cb?: Callback<T>) => R;
                                                                                                                                                                                                        • Echo the given string.

                                                                                                                                                                                                        method ECHO

                                                                                                                                                                                                        ECHO: <T extends string>(message: T, cb?: Callback<T>) => R;

                                                                                                                                                                                                          method expire

                                                                                                                                                                                                          expire: (key: string, seconds: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                          • Set a key's time to live in seconds.

                                                                                                                                                                                                          method EXPIRE

                                                                                                                                                                                                          EXPIRE: (key: string, seconds: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                            method expireat

                                                                                                                                                                                                            expireat: (key: string, timestamp: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                            • Set the expiration for a key as a UNIX timestamp.

                                                                                                                                                                                                            method EXPIREAT

                                                                                                                                                                                                            EXPIREAT: (key: string, timestamp: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                              method flushall

                                                                                                                                                                                                              flushall: {
                                                                                                                                                                                                              (cb?: Callback<string>): R;
                                                                                                                                                                                                              (async: 'ASYNC', cb?: Callback<string>): R;
                                                                                                                                                                                                              };
                                                                                                                                                                                                              • Remove all keys from all databases.

                                                                                                                                                                                                              method FLUSHALL

                                                                                                                                                                                                              FLUSHALL: {
                                                                                                                                                                                                              (cb?: Callback<string>): R;
                                                                                                                                                                                                              (async: 'ASYNC', cb?: Callback<string>): R;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method flushdb

                                                                                                                                                                                                                flushdb: {
                                                                                                                                                                                                                (cb?: Callback<'OK'>): R;
                                                                                                                                                                                                                (async: 'ASYNC', cb?: Callback<string>): R;
                                                                                                                                                                                                                };
                                                                                                                                                                                                                • Remove all keys from the current database.

                                                                                                                                                                                                                method FLUSHDB

                                                                                                                                                                                                                FLUSHDB: {
                                                                                                                                                                                                                (cb?: Callback<'OK'>): R;
                                                                                                                                                                                                                (async: 'ASYNC', cb?: Callback<string>): R;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                  get: (key: string, cb?: Callback<string | null>) => R;
                                                                                                                                                                                                                  • Get the value of a key.

                                                                                                                                                                                                                  method GET

                                                                                                                                                                                                                  GET: (key: string, cb?: Callback<string | null>) => R;

                                                                                                                                                                                                                    method getbit

                                                                                                                                                                                                                    getbit: (key: string, offset: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                                    • Returns the bit value at offset in the string value stored at key.

                                                                                                                                                                                                                    method GETBIT

                                                                                                                                                                                                                    GETBIT: (key: string, offset: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                                      method getrange

                                                                                                                                                                                                                      getrange: (key: string, start: number, end: number, cb?: Callback<string>) => R;
                                                                                                                                                                                                                      • Get a substring of the string stored at a key.

                                                                                                                                                                                                                      method GETRANGE

                                                                                                                                                                                                                      GETRANGE: (key: string, start: number, end: number, cb?: Callback<string>) => R;

                                                                                                                                                                                                                        method getset

                                                                                                                                                                                                                        getset: (key: string, value: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                        • Set the string value of a key and return its old value.

                                                                                                                                                                                                                        method GETSET

                                                                                                                                                                                                                        GETSET: (key: string, value: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                          method hexists

                                                                                                                                                                                                                          hexists: (key: string, field: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                          • Determine if a hash field exists.

                                                                                                                                                                                                                          method HEXISTS

                                                                                                                                                                                                                          HEXISTS: (key: string, field: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                            method hget

                                                                                                                                                                                                                            hget: (key: string, field: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                            • Get the value of a hash field.

                                                                                                                                                                                                                            method HGET

                                                                                                                                                                                                                            HGET: (key: string, field: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                              method hgetall

                                                                                                                                                                                                                              hgetall: (key: string, cb?: Callback<{ [key: string]: string }>) => R;
                                                                                                                                                                                                                              • Get all fields and values in a hash.

                                                                                                                                                                                                                              method HGETALL

                                                                                                                                                                                                                              HGETALL: (key: string, cb?: Callback<{ [key: string]: string }>) => R;

                                                                                                                                                                                                                                method hincrby

                                                                                                                                                                                                                                hincrby: (
                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                field: string,
                                                                                                                                                                                                                                increment: number,
                                                                                                                                                                                                                                cb?: Callback<number>
                                                                                                                                                                                                                                ) => R;
                                                                                                                                                                                                                                • Increment the integer value of a hash field by the given number.

                                                                                                                                                                                                                                method HINCRBY

                                                                                                                                                                                                                                HINCRBY: (
                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                field: string,
                                                                                                                                                                                                                                increment: number,
                                                                                                                                                                                                                                cb?: Callback<number>
                                                                                                                                                                                                                                ) => R;

                                                                                                                                                                                                                                  method hincrbyfloat

                                                                                                                                                                                                                                  hincrbyfloat: (
                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                  field: string,
                                                                                                                                                                                                                                  increment: number,
                                                                                                                                                                                                                                  cb?: Callback<string>
                                                                                                                                                                                                                                  ) => R;
                                                                                                                                                                                                                                  • Increment the float value of a hash field by the given amount.

                                                                                                                                                                                                                                  method HINCRBYFLOAT

                                                                                                                                                                                                                                  HINCRBYFLOAT: (
                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                  field: string,
                                                                                                                                                                                                                                  increment: number,
                                                                                                                                                                                                                                  cb?: Callback<string>
                                                                                                                                                                                                                                  ) => R;

                                                                                                                                                                                                                                    method hkeys

                                                                                                                                                                                                                                    hkeys: (key: string, cb?: Callback<string[]>) => R;
                                                                                                                                                                                                                                    • Get all the fields of a hash.

                                                                                                                                                                                                                                    method HKEYS

                                                                                                                                                                                                                                    HKEYS: (key: string, cb?: Callback<string[]>) => R;

                                                                                                                                                                                                                                      method hlen

                                                                                                                                                                                                                                      hlen: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                      • Get the number of fields in a hash.

                                                                                                                                                                                                                                      method HLEN

                                                                                                                                                                                                                                      HLEN: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                        method hsetnx

                                                                                                                                                                                                                                        hsetnx: (key: string, field: string, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                        • Set the value of a hash field, only if the field does not exist.

                                                                                                                                                                                                                                        method HSETNX

                                                                                                                                                                                                                                        HSETNX: (key: string, field: string, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                          method hstrlen

                                                                                                                                                                                                                                          hstrlen: (key: string, field: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                          • Get the length of the value of a hash field.

                                                                                                                                                                                                                                          method HSTRLEN

                                                                                                                                                                                                                                          HSTRLEN: (key: string, field: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                            method hvals

                                                                                                                                                                                                                                            hvals: (key: string, cb?: Callback<string[]>) => R;
                                                                                                                                                                                                                                            • Get all the values of a hash.

                                                                                                                                                                                                                                            method HVALS

                                                                                                                                                                                                                                            HVALS: (key: string, cb?: Callback<string[]>) => R;

                                                                                                                                                                                                                                              method incr

                                                                                                                                                                                                                                              incr: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                              • Increment the integer value of a key by one.

                                                                                                                                                                                                                                              method INCR

                                                                                                                                                                                                                                              INCR: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                method incrby

                                                                                                                                                                                                                                                incrby: (key: string, increment: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                • Increment the integer value of a key by the given amount.

                                                                                                                                                                                                                                                method INCRBY

                                                                                                                                                                                                                                                INCRBY: (key: string, increment: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                  method incrbyfloat

                                                                                                                                                                                                                                                  incrbyfloat: (key: string, increment: number, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                  • Increment the float value of a key by the given amount.

                                                                                                                                                                                                                                                  method INCRBYFLOAT

                                                                                                                                                                                                                                                  INCRBYFLOAT: (key: string, increment: number, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                    method info

                                                                                                                                                                                                                                                    info: {
                                                                                                                                                                                                                                                    (cb?: Callback<ServerInfo>): R;
                                                                                                                                                                                                                                                    (section?: string | string[], cb?: Callback<ServerInfo>): R;
                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                    • Get information and statistics about the server.

                                                                                                                                                                                                                                                    method INFO

                                                                                                                                                                                                                                                    INFO: {
                                                                                                                                                                                                                                                    (cb?: Callback<ServerInfo>): R;
                                                                                                                                                                                                                                                    (section?: string | string[], cb?: Callback<ServerInfo>): R;
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      method keys

                                                                                                                                                                                                                                                      keys: (pattern: string, cb?: Callback<string[]>) => R;
                                                                                                                                                                                                                                                      • Find all keys matching the given pattern.

                                                                                                                                                                                                                                                      method KEYS

                                                                                                                                                                                                                                                      KEYS: (pattern: string, cb?: Callback<string[]>) => R;

                                                                                                                                                                                                                                                        method lastsave

                                                                                                                                                                                                                                                        lastsave: (cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                        • Get the UNIX time stamp of the last successful save to disk.

                                                                                                                                                                                                                                                        method LASTSAVE

                                                                                                                                                                                                                                                        LASTSAVE: (cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                          method lindex

                                                                                                                                                                                                                                                          lindex: (key: string, index: number, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                          • Get an element from a list by its index.

                                                                                                                                                                                                                                                          method LINDEX

                                                                                                                                                                                                                                                          LINDEX: (key: string, index: number, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                            method linsert

                                                                                                                                                                                                                                                            linsert: (
                                                                                                                                                                                                                                                            key: string,
                                                                                                                                                                                                                                                            dir: 'BEFORE' | 'AFTER',
                                                                                                                                                                                                                                                            pivot: string,
                                                                                                                                                                                                                                                            value: string,
                                                                                                                                                                                                                                                            cb?: Callback<string>
                                                                                                                                                                                                                                                            ) => R;
                                                                                                                                                                                                                                                            • Insert an element before or after another element in a list.

                                                                                                                                                                                                                                                            method LINSERT

                                                                                                                                                                                                                                                            LINSERT: (
                                                                                                                                                                                                                                                            key: string,
                                                                                                                                                                                                                                                            dir: 'BEFORE' | 'AFTER',
                                                                                                                                                                                                                                                            pivot: string,
                                                                                                                                                                                                                                                            value: string,
                                                                                                                                                                                                                                                            cb?: Callback<string>
                                                                                                                                                                                                                                                            ) => R;

                                                                                                                                                                                                                                                              method llen

                                                                                                                                                                                                                                                              llen: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                              • Get the length of a list.

                                                                                                                                                                                                                                                              method LLEN

                                                                                                                                                                                                                                                              LLEN: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                method lpop

                                                                                                                                                                                                                                                                lpop: (key: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                • Remove and get the first element in a list.

                                                                                                                                                                                                                                                                method LPOP

                                                                                                                                                                                                                                                                LPOP: (key: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                  method lpushx

                                                                                                                                                                                                                                                                  lpushx: (key: string, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                  • Prepend a value to a list, only if the list exists.

                                                                                                                                                                                                                                                                  method LPUSHX

                                                                                                                                                                                                                                                                  LPUSHX: (key: string, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                    method lrange

                                                                                                                                                                                                                                                                    lrange: (key: string, start: number, stop: number, cb?: Callback<string[]>) => R;
                                                                                                                                                                                                                                                                    • Get a range of elements from a list.

                                                                                                                                                                                                                                                                    method LRANGE

                                                                                                                                                                                                                                                                    LRANGE: (key: string, start: number, stop: number, cb?: Callback<string[]>) => R;

                                                                                                                                                                                                                                                                      method lrem

                                                                                                                                                                                                                                                                      lrem: (key: string, count: number, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                      • Remove elements from a list.

                                                                                                                                                                                                                                                                      method LREM

                                                                                                                                                                                                                                                                      LREM: (key: string, count: number, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                        method lset

                                                                                                                                                                                                                                                                        lset: (key: string, index: number, value: string, cb?: Callback<'OK'>) => R;
                                                                                                                                                                                                                                                                        • Set the value of an element in a list by its index.

                                                                                                                                                                                                                                                                        method LSET

                                                                                                                                                                                                                                                                        LSET: (key: string, index: number, value: string, cb?: Callback<'OK'>) => R;

                                                                                                                                                                                                                                                                          method ltrim

                                                                                                                                                                                                                                                                          ltrim: (key: string, start: number, stop: number, cb?: Callback<'OK'>) => R;
                                                                                                                                                                                                                                                                          • Trim a list to the specified range.

                                                                                                                                                                                                                                                                          method LTRIM

                                                                                                                                                                                                                                                                          LTRIM: (key: string, start: number, stop: number, cb?: Callback<'OK'>) => R;

                                                                                                                                                                                                                                                                            method monitor

                                                                                                                                                                                                                                                                            monitor: (cb?: Callback<undefined>) => R;
                                                                                                                                                                                                                                                                            • Listen for all requests received by the server in real time.

                                                                                                                                                                                                                                                                            method MONITOR

                                                                                                                                                                                                                                                                            MONITOR: (cb?: Callback<undefined>) => R;

                                                                                                                                                                                                                                                                              method move

                                                                                                                                                                                                                                                                              move: (key: string, db: string | number) => R;
                                                                                                                                                                                                                                                                              • Move a key to another database.

                                                                                                                                                                                                                                                                              method MOVE

                                                                                                                                                                                                                                                                              MOVE: (key: string, db: string | number) => R;

                                                                                                                                                                                                                                                                                method persist

                                                                                                                                                                                                                                                                                persist: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                • Remove the expiration from a key.

                                                                                                                                                                                                                                                                                method PERSIST

                                                                                                                                                                                                                                                                                PERSIST: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                  method pexpire

                                                                                                                                                                                                                                                                                  pexpire: (key: string, milliseconds: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                  • Remove a key's time to live in milliseconds.

                                                                                                                                                                                                                                                                                  method PEXPIRE

                                                                                                                                                                                                                                                                                  PEXPIRE: (key: string, milliseconds: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                    method pexpireat

                                                                                                                                                                                                                                                                                    pexpireat: (
                                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                                    millisecondsTimestamp: number,
                                                                                                                                                                                                                                                                                    cb?: Callback<number>
                                                                                                                                                                                                                                                                                    ) => R;
                                                                                                                                                                                                                                                                                    • Set the expiration for a key as a UNIX timestamp specified in milliseconds.

                                                                                                                                                                                                                                                                                    method PEXPIREAT

                                                                                                                                                                                                                                                                                    PEXPIREAT: (
                                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                                    millisecondsTimestamp: number,
                                                                                                                                                                                                                                                                                    cb?: Callback<number>
                                                                                                                                                                                                                                                                                    ) => R;

                                                                                                                                                                                                                                                                                      method ping

                                                                                                                                                                                                                                                                                      ping: {
                                                                                                                                                                                                                                                                                      (callback?: Callback<string>): R;
                                                                                                                                                                                                                                                                                      (message: string, callback?: Callback<string>): R;
                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                      • Ping the server.

                                                                                                                                                                                                                                                                                      method PING

                                                                                                                                                                                                                                                                                      PING: {
                                                                                                                                                                                                                                                                                      (callback?: Callback<string>): R;
                                                                                                                                                                                                                                                                                      (message: string, callback?: Callback<string>): R;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        method psetex

                                                                                                                                                                                                                                                                                        psetex: (
                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                        milliseconds: number,
                                                                                                                                                                                                                                                                                        value: string,
                                                                                                                                                                                                                                                                                        cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                        ) => R;
                                                                                                                                                                                                                                                                                        • Set the value and expiration in milliseconds of a key.

                                                                                                                                                                                                                                                                                        method PSETEX

                                                                                                                                                                                                                                                                                        PSETEX: (
                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                        milliseconds: number,
                                                                                                                                                                                                                                                                                        value: string,
                                                                                                                                                                                                                                                                                        cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                        ) => R;

                                                                                                                                                                                                                                                                                          method pttl

                                                                                                                                                                                                                                                                                          pttl: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                          • Get the time to live for a key in milliseconds.

                                                                                                                                                                                                                                                                                          method PTTL

                                                                                                                                                                                                                                                                                          PTTL: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                            method publish

                                                                                                                                                                                                                                                                                            publish: (channel: string, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                            • Post a message to a channel.

                                                                                                                                                                                                                                                                                            method PUBLISH

                                                                                                                                                                                                                                                                                            PUBLISH: (channel: string, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                              method quit

                                                                                                                                                                                                                                                                                              quit: (cb?: Callback<'OK'>) => R;
                                                                                                                                                                                                                                                                                              • Close the connection.

                                                                                                                                                                                                                                                                                              method QUIT

                                                                                                                                                                                                                                                                                              QUIT: (cb?: Callback<'OK'>) => R;

                                                                                                                                                                                                                                                                                                method randomkey

                                                                                                                                                                                                                                                                                                randomkey: (cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                • Return a random key from the keyspace.

                                                                                                                                                                                                                                                                                                method RANDOMKEY

                                                                                                                                                                                                                                                                                                RANDOMKEY: (cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                  method readonly

                                                                                                                                                                                                                                                                                                  readonly: (cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                  • Enables read queries for a connection to a cluster slave node.

                                                                                                                                                                                                                                                                                                  method READONLY

                                                                                                                                                                                                                                                                                                  READONLY: (cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                    method readwrite

                                                                                                                                                                                                                                                                                                    readwrite: (cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                    • Disables read queries for a connection to cluster slave node.

                                                                                                                                                                                                                                                                                                    method READWRITE

                                                                                                                                                                                                                                                                                                    READWRITE: (cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                      method rename

                                                                                                                                                                                                                                                                                                      rename: (key: string, newkey: string, cb?: Callback<'OK'>) => R;
                                                                                                                                                                                                                                                                                                      • Rename a key.

                                                                                                                                                                                                                                                                                                      method RENAME

                                                                                                                                                                                                                                                                                                      RENAME: (key: string, newkey: string, cb?: Callback<'OK'>) => R;

                                                                                                                                                                                                                                                                                                        method renamenx

                                                                                                                                                                                                                                                                                                        renamenx: (key: string, newkey: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                        • Rename a key, only if the new key does not exist.

                                                                                                                                                                                                                                                                                                        method RENAMENX

                                                                                                                                                                                                                                                                                                        RENAMENX: (key: string, newkey: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                          method restore

                                                                                                                                                                                                                                                                                                          restore: (
                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                          ttl: number,
                                                                                                                                                                                                                                                                                                          serializedValue: string,
                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                          ) => R;
                                                                                                                                                                                                                                                                                                          • Create a key using the provided serialized value, previously obtained using DUMP.

                                                                                                                                                                                                                                                                                                          method RESTORE

                                                                                                                                                                                                                                                                                                          RESTORE: (
                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                          ttl: number,
                                                                                                                                                                                                                                                                                                          serializedValue: string,
                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                          ) => R;

                                                                                                                                                                                                                                                                                                            method role

                                                                                                                                                                                                                                                                                                            role: (cb?: Callback<[string, number, Array<[string, string, string]>]>) => R;
                                                                                                                                                                                                                                                                                                            • Return the role of the instance in the context of replication.

                                                                                                                                                                                                                                                                                                            method ROLE

                                                                                                                                                                                                                                                                                                            ROLE: (cb?: Callback<[string, number, Array<[string, string, string]>]>) => R;

                                                                                                                                                                                                                                                                                                              method rpop

                                                                                                                                                                                                                                                                                                              rpop: (key: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                              • Remove and get the last element in a list.

                                                                                                                                                                                                                                                                                                              method RPOP

                                                                                                                                                                                                                                                                                                              RPOP: (key: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                method rpoplpush

                                                                                                                                                                                                                                                                                                                rpoplpush: (source: string, destination: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                • Remove the last element in a list, prepend it to another list and return it.

                                                                                                                                                                                                                                                                                                                method RPOPLPUSH

                                                                                                                                                                                                                                                                                                                RPOPLPUSH: (source: string, destination: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                  method rpushx

                                                                                                                                                                                                                                                                                                                  rpushx: (key: string, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                  • Append a value to a list, only if the list exists.

                                                                                                                                                                                                                                                                                                                  method RPUSHX

                                                                                                                                                                                                                                                                                                                  RPUSHX: (key: string, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                    method save

                                                                                                                                                                                                                                                                                                                    save: (cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                    • Synchronously save the dataset to disk.

                                                                                                                                                                                                                                                                                                                    method SAVE

                                                                                                                                                                                                                                                                                                                    SAVE: (cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                      method scard

                                                                                                                                                                                                                                                                                                                      scard: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                      • Get the number of members in a set.

                                                                                                                                                                                                                                                                                                                      method SCARD

                                                                                                                                                                                                                                                                                                                      SCARD: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                        method select

                                                                                                                                                                                                                                                                                                                        select: (index: number | string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                        • Change the selected database for the current connection.

                                                                                                                                                                                                                                                                                                                        method SELECT

                                                                                                                                                                                                                                                                                                                        SELECT: (index: number | string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                          method set

                                                                                                                                                                                                                                                                                                                          set: {
                                                                                                                                                                                                                                                                                                                          (key: string, value: string, cb?: Callback<'OK'>): R;
                                                                                                                                                                                                                                                                                                                          (key: string, value: string, flag: string, cb?: Callback<'OK'>): R;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                          value: string,
                                                                                                                                                                                                                                                                                                                          mode: string,
                                                                                                                                                                                                                                                                                                                          duration: number,
                                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                          value: string,
                                                                                                                                                                                                                                                                                                                          mode: string,
                                                                                                                                                                                                                                                                                                                          duration: number,
                                                                                                                                                                                                                                                                                                                          flag: string,
                                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                          value: string,
                                                                                                                                                                                                                                                                                                                          flag: string,
                                                                                                                                                                                                                                                                                                                          mode: string,
                                                                                                                                                                                                                                                                                                                          duration: number,
                                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                          • Set the string value of a key.

                                                                                                                                                                                                                                                                                                                          method SET

                                                                                                                                                                                                                                                                                                                          SET: {
                                                                                                                                                                                                                                                                                                                          (key: string, value: string, cb?: Callback<'OK'>): R;
                                                                                                                                                                                                                                                                                                                          (key: string, value: string, flag: string, cb?: Callback<'OK'>): R;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                          value: string,
                                                                                                                                                                                                                                                                                                                          mode: string,
                                                                                                                                                                                                                                                                                                                          duration: number,
                                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                          value: string,
                                                                                                                                                                                                                                                                                                                          mode: string,
                                                                                                                                                                                                                                                                                                                          duration: number,
                                                                                                                                                                                                                                                                                                                          flag: string,
                                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                          value: string,
                                                                                                                                                                                                                                                                                                                          flag: string,
                                                                                                                                                                                                                                                                                                                          mode: string,
                                                                                                                                                                                                                                                                                                                          duration: number,
                                                                                                                                                                                                                                                                                                                          cb?: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            method setbit

                                                                                                                                                                                                                                                                                                                            setbit: (key: string, offset: number, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                            • Sets or clears the bit at offset in the string value stored at key.

                                                                                                                                                                                                                                                                                                                            method SETBIT

                                                                                                                                                                                                                                                                                                                            SETBIT: (key: string, offset: number, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                              method setex

                                                                                                                                                                                                                                                                                                                              setex: (key: string, seconds: number, value: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                              • Set the value and expiration of a key.

                                                                                                                                                                                                                                                                                                                              method SETEX

                                                                                                                                                                                                                                                                                                                              SETEX: (key: string, seconds: number, value: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                                method setnx

                                                                                                                                                                                                                                                                                                                                setnx: (key: string, value: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                • Set the value of a key, only if the key does not exist.

                                                                                                                                                                                                                                                                                                                                method SETNX

                                                                                                                                                                                                                                                                                                                                SETNX: (key: string, value: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                  method setrange

                                                                                                                                                                                                                                                                                                                                  setrange: (
                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                  offset: number,
                                                                                                                                                                                                                                                                                                                                  value: string,
                                                                                                                                                                                                                                                                                                                                  cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                  ) => R;
                                                                                                                                                                                                                                                                                                                                  • Overwrite part of a string at key starting at the specified offset.

                                                                                                                                                                                                                                                                                                                                  method SETRANGE

                                                                                                                                                                                                                                                                                                                                  SETRANGE: (
                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                  offset: number,
                                                                                                                                                                                                                                                                                                                                  value: string,
                                                                                                                                                                                                                                                                                                                                  cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                  ) => R;

                                                                                                                                                                                                                                                                                                                                    method sismember

                                                                                                                                                                                                                                                                                                                                    sismember: (key: string, member: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                    • Determine if a given value is a member of a set.

                                                                                                                                                                                                                                                                                                                                    method SISMEMBER

                                                                                                                                                                                                                                                                                                                                    SISMEMBER: (key: string, member: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                      method slaveof

                                                                                                                                                                                                                                                                                                                                      slaveof: (host: string, port: string | number, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                                      • Make the server a slave of another instance, or promote it as master.

                                                                                                                                                                                                                                                                                                                                      method SLAVEOF

                                                                                                                                                                                                                                                                                                                                      SLAVEOF: (host: string, port: string | number, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                                        method smembers

                                                                                                                                                                                                                                                                                                                                        smembers: (key: string, cb?: Callback<string[]>) => R;
                                                                                                                                                                                                                                                                                                                                        • Get all the members in a set.

                                                                                                                                                                                                                                                                                                                                        method SMEMBERS

                                                                                                                                                                                                                                                                                                                                        SMEMBERS: (key: string, cb?: Callback<string[]>) => R;

                                                                                                                                                                                                                                                                                                                                          method smove

                                                                                                                                                                                                                                                                                                                                          smove: (
                                                                                                                                                                                                                                                                                                                                          source: string,
                                                                                                                                                                                                                                                                                                                                          destination: string,
                                                                                                                                                                                                                                                                                                                                          member: string,
                                                                                                                                                                                                                                                                                                                                          cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                          ) => R;
                                                                                                                                                                                                                                                                                                                                          • Move a member from one set to another.

                                                                                                                                                                                                                                                                                                                                          method SMOVE

                                                                                                                                                                                                                                                                                                                                          SMOVE: (
                                                                                                                                                                                                                                                                                                                                          source: string,
                                                                                                                                                                                                                                                                                                                                          destination: string,
                                                                                                                                                                                                                                                                                                                                          member: string,
                                                                                                                                                                                                                                                                                                                                          cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                          ) => R;

                                                                                                                                                                                                                                                                                                                                            method spop

                                                                                                                                                                                                                                                                                                                                            spop: {
                                                                                                                                                                                                                                                                                                                                            (key: string, cb?: Callback<string>): R;
                                                                                                                                                                                                                                                                                                                                            (key: string, count: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                            • Remove and return one or multiple random members from a set.

                                                                                                                                                                                                                                                                                                                                            method SPOP

                                                                                                                                                                                                                                                                                                                                            SPOP: {
                                                                                                                                                                                                                                                                                                                                            (key: string, cb?: Callback<string>): R;
                                                                                                                                                                                                                                                                                                                                            (key: string, count: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              method srandmember

                                                                                                                                                                                                                                                                                                                                              srandmember: {
                                                                                                                                                                                                                                                                                                                                              (key: string, cb?: Callback<string>): R;
                                                                                                                                                                                                                                                                                                                                              (key: string, count: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                              • Get one or multiple random members from a set.

                                                                                                                                                                                                                                                                                                                                              method SRANDMEMBER

                                                                                                                                                                                                                                                                                                                                              SRANDMEMBER: {
                                                                                                                                                                                                                                                                                                                                              (key: string, cb?: Callback<string>): R;
                                                                                                                                                                                                                                                                                                                                              (key: string, count: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                method strlen

                                                                                                                                                                                                                                                                                                                                                strlen: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                                • Get the length of the value stored in a key.

                                                                                                                                                                                                                                                                                                                                                method STRLEN

                                                                                                                                                                                                                                                                                                                                                STRLEN: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                                  method sync

                                                                                                                                                                                                                                                                                                                                                  sync: (cb?: Callback<undefined>) => R;
                                                                                                                                                                                                                                                                                                                                                  • Internal command used for replication.

                                                                                                                                                                                                                                                                                                                                                  method SYNC

                                                                                                                                                                                                                                                                                                                                                  SYNC: (cb?: Callback<undefined>) => R;

                                                                                                                                                                                                                                                                                                                                                    method time

                                                                                                                                                                                                                                                                                                                                                    time: (cb?: Callback<[string, string]>) => R;
                                                                                                                                                                                                                                                                                                                                                    • Return the current server time.

                                                                                                                                                                                                                                                                                                                                                    method TIME

                                                                                                                                                                                                                                                                                                                                                    TIME: (cb?: Callback<[string, string]>) => R;

                                                                                                                                                                                                                                                                                                                                                      method ttl

                                                                                                                                                                                                                                                                                                                                                      ttl: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                                      • Get the time to live for a key.

                                                                                                                                                                                                                                                                                                                                                      method TTL

                                                                                                                                                                                                                                                                                                                                                      TTL: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                                        method type

                                                                                                                                                                                                                                                                                                                                                        type: (key: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                                                        • Determine the type stored at key.

                                                                                                                                                                                                                                                                                                                                                        method TYPE

                                                                                                                                                                                                                                                                                                                                                        TYPE: (key: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                                                          method unwatch

                                                                                                                                                                                                                                                                                                                                                          unwatch: (cb?: Callback<'OK'>) => R;
                                                                                                                                                                                                                                                                                                                                                          • Forget about all watched keys.

                                                                                                                                                                                                                                                                                                                                                          method UNWATCH

                                                                                                                                                                                                                                                                                                                                                          UNWATCH: (cb?: Callback<'OK'>) => R;

                                                                                                                                                                                                                                                                                                                                                            method wait

                                                                                                                                                                                                                                                                                                                                                            wait: (numslaves: number, timeout: number, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                                            • Wait for the synchronous replication of all the write commands sent in the context of the current connection.

                                                                                                                                                                                                                                                                                                                                                            method WAIT

                                                                                                                                                                                                                                                                                                                                                            WAIT: (numslaves: number, timeout: number, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                                              method zcard

                                                                                                                                                                                                                                                                                                                                                              zcard: (key: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                                              • Get the number of members in a sorted set.

                                                                                                                                                                                                                                                                                                                                                              method ZCARD

                                                                                                                                                                                                                                                                                                                                                              ZCARD: (key: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                                                method zcount

                                                                                                                                                                                                                                                                                                                                                                zcount: (
                                                                                                                                                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                                                                                                                                                min: number | string,
                                                                                                                                                                                                                                                                                                                                                                max: number | string,
                                                                                                                                                                                                                                                                                                                                                                cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                ) => R;
                                                                                                                                                                                                                                                                                                                                                                • Count the members in a sorted set with scores between the given values.

                                                                                                                                                                                                                                                                                                                                                                method ZCOUNT

                                                                                                                                                                                                                                                                                                                                                                ZCOUNT: (
                                                                                                                                                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                                                                                                                                                min: number | string,
                                                                                                                                                                                                                                                                                                                                                                max: number | string,
                                                                                                                                                                                                                                                                                                                                                                cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                ) => R;

                                                                                                                                                                                                                                                                                                                                                                  method zincrby

                                                                                                                                                                                                                                                                                                                                                                  zincrby: (
                                                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                                                  increment: number,
                                                                                                                                                                                                                                                                                                                                                                  member: string,
                                                                                                                                                                                                                                                                                                                                                                  cb?: Callback<string>
                                                                                                                                                                                                                                                                                                                                                                  ) => R;
                                                                                                                                                                                                                                                                                                                                                                  • Increment the score of a member in a sorted set.

                                                                                                                                                                                                                                                                                                                                                                  method ZINCRBY

                                                                                                                                                                                                                                                                                                                                                                  ZINCRBY: (
                                                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                                                  increment: number,
                                                                                                                                                                                                                                                                                                                                                                  member: string,
                                                                                                                                                                                                                                                                                                                                                                  cb?: Callback<string>
                                                                                                                                                                                                                                                                                                                                                                  ) => R;

                                                                                                                                                                                                                                                                                                                                                                    method zlexcount

                                                                                                                                                                                                                                                                                                                                                                    zlexcount: (key: string, min: string, max: string, cb?: Callback<number>) => R;
                                                                                                                                                                                                                                                                                                                                                                    • Count the number of members in a sorted set between a given lexicographic range.

                                                                                                                                                                                                                                                                                                                                                                    method ZLEXCOUNT

                                                                                                                                                                                                                                                                                                                                                                    ZLEXCOUNT: (key: string, min: string, max: string, cb?: Callback<number>) => R;

                                                                                                                                                                                                                                                                                                                                                                      method zrange

                                                                                                                                                                                                                                                                                                                                                                      zrange: {
                                                                                                                                                                                                                                                                                                                                                                      (key: string, start: number, stop: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                      key: string,
                                                                                                                                                                                                                                                                                                                                                                      start: number,
                                                                                                                                                                                                                                                                                                                                                                      stop: number,
                                                                                                                                                                                                                                                                                                                                                                      withscores: string,
                                                                                                                                                                                                                                                                                                                                                                      cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                      ): R;
                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                      • Return a range of members in a sorted set, by index.

                                                                                                                                                                                                                                                                                                                                                                      method ZRANGE

                                                                                                                                                                                                                                                                                                                                                                      ZRANGE: {
                                                                                                                                                                                                                                                                                                                                                                      (key: string, start: number, stop: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                      key: string,
                                                                                                                                                                                                                                                                                                                                                                      start: number,
                                                                                                                                                                                                                                                                                                                                                                      stop: number,
                                                                                                                                                                                                                                                                                                                                                                      withscores: string,
                                                                                                                                                                                                                                                                                                                                                                      cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                      ): R;
                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                        method zrangebylex

                                                                                                                                                                                                                                                                                                                                                                        zrangebylex: {
                                                                                                                                                                                                                                                                                                                                                                        (key: string, min: string, max: string, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                        min: string,
                                                                                                                                                                                                                                                                                                                                                                        max: string,
                                                                                                                                                                                                                                                                                                                                                                        limit: string,
                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                        • Return a range of members in a sorted set, by lexicographical range.

                                                                                                                                                                                                                                                                                                                                                                        method ZRANGEBYLEX

                                                                                                                                                                                                                                                                                                                                                                        ZRANGEBYLEX: {
                                                                                                                                                                                                                                                                                                                                                                        (key: string, min: string, max: string, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                        min: string,
                                                                                                                                                                                                                                                                                                                                                                        max: string,
                                                                                                                                                                                                                                                                                                                                                                        limit: string,
                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                          method zrangebyscore

                                                                                                                                                                                                                                                                                                                                                                          zrangebyscore: {
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: number | string,
                                                                                                                                                                                                                                                                                                                                                                          max: number | string,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                          withscores: string,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                          limit: string,
                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                          withscores: string,
                                                                                                                                                                                                                                                                                                                                                                          limit: string,
                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                          • Return a range of members in a sorted set, by score.

                                                                                                                                                                                                                                                                                                                                                                          method ZRANGEBYSCORE

                                                                                                                                                                                                                                                                                                                                                                          ZRANGEBYSCORE: {
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: number | string,
                                                                                                                                                                                                                                                                                                                                                                          max: number | string,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                          withscores: string,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                          limit: string,
                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                          withscores: string,
                                                                                                                                                                                                                                                                                                                                                                          limit: string,
                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                          ): R;
                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                            method zrank

                                                                                                                                                                                                                                                                                                                                                                            zrank: (key: string, member: string, cb?: Callback<number | null>) => R;
                                                                                                                                                                                                                                                                                                                                                                            • Determine the index of a member in a sorted set.

                                                                                                                                                                                                                                                                                                                                                                            method ZRANK

                                                                                                                                                                                                                                                                                                                                                                            ZRANK: (key: string, member: string, cb?: Callback<number | null>) => R;

                                                                                                                                                                                                                                                                                                                                                                              method zremrangebylex

                                                                                                                                                                                                                                                                                                                                                                              zremrangebylex: (
                                                                                                                                                                                                                                                                                                                                                                              key: string,
                                                                                                                                                                                                                                                                                                                                                                              min: string,
                                                                                                                                                                                                                                                                                                                                                                              max: string,
                                                                                                                                                                                                                                                                                                                                                                              cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                              ) => R;
                                                                                                                                                                                                                                                                                                                                                                              • Remove all members in a sorted set between the given lexicographical range.

                                                                                                                                                                                                                                                                                                                                                                              method ZREMRANGEBYLEX

                                                                                                                                                                                                                                                                                                                                                                              ZREMRANGEBYLEX: (
                                                                                                                                                                                                                                                                                                                                                                              key: string,
                                                                                                                                                                                                                                                                                                                                                                              min: string,
                                                                                                                                                                                                                                                                                                                                                                              max: string,
                                                                                                                                                                                                                                                                                                                                                                              cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                              ) => R;

                                                                                                                                                                                                                                                                                                                                                                                method zremrangebyrank

                                                                                                                                                                                                                                                                                                                                                                                zremrangebyrank: (
                                                                                                                                                                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                                                                                                                                                                start: number,
                                                                                                                                                                                                                                                                                                                                                                                stop: number,
                                                                                                                                                                                                                                                                                                                                                                                cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                ) => R;
                                                                                                                                                                                                                                                                                                                                                                                • Remove all members in a sorted set within the given indexes.

                                                                                                                                                                                                                                                                                                                                                                                method ZREMRANGEBYRANK

                                                                                                                                                                                                                                                                                                                                                                                ZREMRANGEBYRANK: (
                                                                                                                                                                                                                                                                                                                                                                                key: string,
                                                                                                                                                                                                                                                                                                                                                                                start: number,
                                                                                                                                                                                                                                                                                                                                                                                stop: number,
                                                                                                                                                                                                                                                                                                                                                                                cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                ) => R;

                                                                                                                                                                                                                                                                                                                                                                                  method zremrangebyscore

                                                                                                                                                                                                                                                                                                                                                                                  zremrangebyscore: (
                                                                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                                                                  min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                  max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                  cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                  ) => R;
                                                                                                                                                                                                                                                                                                                                                                                  • Remove all members in a sorted set within the given indexes.

                                                                                                                                                                                                                                                                                                                                                                                  method ZREMRANGEBYSCORE

                                                                                                                                                                                                                                                                                                                                                                                  ZREMRANGEBYSCORE: (
                                                                                                                                                                                                                                                                                                                                                                                  key: string,
                                                                                                                                                                                                                                                                                                                                                                                  min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                  max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                  cb?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                  ) => R;

                                                                                                                                                                                                                                                                                                                                                                                    method zrevrange

                                                                                                                                                                                                                                                                                                                                                                                    zrevrange: {
                                                                                                                                                                                                                                                                                                                                                                                    (key: string, start: number, stop: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                                                                                                                                    start: number,
                                                                                                                                                                                                                                                                                                                                                                                    stop: number,
                                                                                                                                                                                                                                                                                                                                                                                    withscores: string,
                                                                                                                                                                                                                                                                                                                                                                                    cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                    ): R;
                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                    • Return a range of members in a sorted set, by index, with scores ordered from high to low.

                                                                                                                                                                                                                                                                                                                                                                                    method ZREVRANGE

                                                                                                                                                                                                                                                                                                                                                                                    ZREVRANGE: {
                                                                                                                                                                                                                                                                                                                                                                                    (key: string, start: number, stop: number, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                    key: string,
                                                                                                                                                                                                                                                                                                                                                                                    start: number,
                                                                                                                                                                                                                                                                                                                                                                                    stop: number,
                                                                                                                                                                                                                                                                                                                                                                                    withscores: string,
                                                                                                                                                                                                                                                                                                                                                                                    cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                    ): R;
                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                      method zrevrangebylex

                                                                                                                                                                                                                                                                                                                                                                                      zrevrangebylex: {
                                                                                                                                                                                                                                                                                                                                                                                      (key: string, min: string, max: string, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                      key: string,
                                                                                                                                                                                                                                                                                                                                                                                      min: string,
                                                                                                                                                                                                                                                                                                                                                                                      max: string,
                                                                                                                                                                                                                                                                                                                                                                                      limit: string,
                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                      count: number,
                                                                                                                                                                                                                                                                                                                                                                                      cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                      ): R;
                                                                                                                                                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                                                                                                                                                      • Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

                                                                                                                                                                                                                                                                                                                                                                                      method ZREVRANGEBYLEX

                                                                                                                                                                                                                                                                                                                                                                                      ZREVRANGEBYLEX: {
                                                                                                                                                                                                                                                                                                                                                                                      (key: string, min: string, max: string, cb?: Callback<string[]>): R;
                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                      key: string,
                                                                                                                                                                                                                                                                                                                                                                                      min: string,
                                                                                                                                                                                                                                                                                                                                                                                      max: string,
                                                                                                                                                                                                                                                                                                                                                                                      limit: string,
                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                      count: number,
                                                                                                                                                                                                                                                                                                                                                                                      cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                      ): R;
                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                        method zrevrangebyscore

                                                                                                                                                                                                                                                                                                                                                                                        zrevrangebyscore: {
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                        max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        withscores: string,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        limit: string,
                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        withscores: string,
                                                                                                                                                                                                                                                                                                                                                                                        limit: string,
                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                        • Return a range of members in a sorted set, by score, with scores ordered from high to low.

                                                                                                                                                                                                                                                                                                                                                                                        method ZREVRANGEBYSCORE

                                                                                                                                                                                                                                                                                                                                                                                        ZREVRANGEBYSCORE: {
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                        max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        withscores: string,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        limit: string,
                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                        key: string,
                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                        withscores: string,
                                                                                                                                                                                                                                                                                                                                                                                        limit: string,
                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                                        cb?: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                        ): R;
                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                          method zrevrank

                                                                                                                                                                                                                                                                                                                                                                                          zrevrank: (key: string, member: string, cb?: Callback<number | null>) => R;
                                                                                                                                                                                                                                                                                                                                                                                          • Determine the index of a member in a sorted set, with scores ordered from high to low.

                                                                                                                                                                                                                                                                                                                                                                                          method ZREVRANK

                                                                                                                                                                                                                                                                                                                                                                                          ZREVRANK: (key: string, member: string, cb?: Callback<number | null>) => R;

                                                                                                                                                                                                                                                                                                                                                                                            method zscore

                                                                                                                                                                                                                                                                                                                                                                                            zscore: (key: string, member: string, cb?: Callback<string>) => R;
                                                                                                                                                                                                                                                                                                                                                                                            • Get the score associated with the given member in a sorted set.

                                                                                                                                                                                                                                                                                                                                                                                            method ZSCORE

                                                                                                                                                                                                                                                                                                                                                                                            ZSCORE: (key: string, member: string, cb?: Callback<string>) => R;

                                                                                                                                                                                                                                                                                                                                                                                              interface Multi

                                                                                                                                                                                                                                                                                                                                                                                              interface Multi extends Commands<Multi> {}

                                                                                                                                                                                                                                                                                                                                                                                                method exec

                                                                                                                                                                                                                                                                                                                                                                                                exec: (cb?: Callback<any[]>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                  method EXEC

                                                                                                                                                                                                                                                                                                                                                                                                  EXEC: (cb?: Callback<any[]>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    method exec_atomic

                                                                                                                                                                                                                                                                                                                                                                                                    exec_atomic: (cb?: Callback<any[]>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                      method EXEC_ATOMIC

                                                                                                                                                                                                                                                                                                                                                                                                      EXEC_ATOMIC: (cb?: Callback<any[]>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                        interface OverloadedCommand

                                                                                                                                                                                                                                                                                                                                                                                                        interface OverloadedCommand<T, U, R> {}

                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                          (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, arg6: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                            (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                              (arg1: T, arg2: T, arg3: T, arg4: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                (arg1: T, arg2: T, arg3: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                  (arg1: T, arg2: T | T[], cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                    (arg1: T | T[], cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                      (...args: Array<T | Callback<U>>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                        interface OverloadedKeyCommand

                                                                                                                                                                                                                                                                                                                                                                                                                        interface OverloadedKeyCommand<T, U, R> {}

                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                          arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                          arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                          arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                          arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                          arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                          arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                          cb?: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                          ): R;

                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                            (key: string, arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                              (key: string, arg1: T, arg2: T, arg3: T, arg4: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                (key: string, arg1: T, arg2: T, arg3: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: string, arg1: T, arg2: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                    (key: string, arg1: T | T[], cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: string, ...args: Array<T | Callback<U>>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                        (...args: Array<string | T | Callback<U>>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OverloadedLastCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OverloadedLastCommand<T1, T2, U, R> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                            arg1: T1,
                                                                                                                                                                                                                                                                                                                                                                                                                                            arg2: T1,
                                                                                                                                                                                                                                                                                                                                                                                                                                            arg3: T1,
                                                                                                                                                                                                                                                                                                                                                                                                                                            arg4: T1,
                                                                                                                                                                                                                                                                                                                                                                                                                                            arg5: T1,
                                                                                                                                                                                                                                                                                                                                                                                                                                            arg6: T2,
                                                                                                                                                                                                                                                                                                                                                                                                                                            cb?: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                            ): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                              (arg1: T1, arg2: T1, arg3: T1, arg4: T1, arg5: T2, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                (arg1: T1, arg2: T1, arg3: T1, arg4: T2, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                  (arg1: T1, arg2: T1, arg3: T2, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                    (arg1: T1, arg2: T2 | Array<T1 | T2>, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                      (args: Array<T1 | T2>, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                        (...args: Array<T1 | T2 | Callback<U>>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OverloadedListCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OverloadedListCommand<T, U, R> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                            (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, arg6: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                              (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                (arg1: T, arg2: T, arg3: T, arg4: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (arg1: T, arg2: T, arg3: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (arg1: T, arg2: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (arg1: T | T[], cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (...args: Array<T | Callback<U>>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OverloadedSetCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface OverloadedSetCommand<T, U, R> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cb?: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (key: string, arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: string, arg1: T, arg2: T, arg3: T, arg4: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: string, arg1: T, arg2: T, arg3: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (key: string, arg1: T, arg2: T, cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: string, arg1: T | { [key: string]: T } | T[], cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: string, ...args: Array<T | Callback<U>>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (args: [string, ...T[]], cb?: Callback<U>): R;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RedisClient

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RedisClient extends Commands<boolean>, EventEmitter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property command_queue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              command_queue: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property command_queue_length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                command_queue_length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property connected

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  connected: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property connection_id

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    connection_id: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property offline_queue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offline_queue: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property offline_queue_length

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offline_queue_length: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property retry_backoff

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          retry_backoff: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property retry_delay

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            retry_delay: number | Error;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property server_info

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              server_info: ServerInfo;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stream: Duplex;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method batch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  batch: (args?: Array<Array<string | number | Callback<any>>>) => Multi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method BATCH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    BATCH: (args?: Array<Array<string | number | Callback<any>>>) => Multi;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method cork

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cork: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method duplicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        duplicate: (options?: ClientOpts, cb?: Callback<RedisClient>) => RedisClient;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          end: (flush?: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Client methods.