@types/redis

  • Version 2.8.29
  • Published
  • 60 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 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;

                                          property connect_timeout

                                          connect_timeout?: number;

                                            property db

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

                                            property detect_buffers

                                            detect_buffers?: boolean;
                                            • 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;
                                            • If set to true, a client won't resubscribe after disconnecting. false

                                            property enable_offline_queue

                                            enable_offline_queue?: boolean;
                                            • 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;
                                            • 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;
                                            • IP address of the Redis server. 127.0.0.1

                                            property max_attempts

                                            max_attempts?: number;

                                              property no_ready_check

                                              no_ready_check?: boolean;
                                              • 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;

                                                property password

                                                password?: string;
                                                • 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;
                                                • The UNIX socket string of the Redis server. null

                                                property port

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

                                                property prefix

                                                prefix?: string;
                                                • 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;
                                                • 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;

                                                  property retry_strategy

                                                  retry_strategy?: RetryStrategy;
                                                  • 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;
                                                  • 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;
                                                  • 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;
                                                  • 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;
                                                  • If set to true, the keep-alive functionality is enabled on the underlying socket. true

                                                  property string_numbers

                                                  string_numbers?: boolean;
                                                  • 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](http://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;
                                                  • 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 add_command

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              add_command: (command: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method addCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                addCommand: (command: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method multi

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          multi: (args?: Array<Array<string | number | Callback<any>>>) => Multi;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Mark the start of a transaction block.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method MULTI

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          MULTI: (args?: Array<Array<string<