@types/ioredis

  • Version 4.28.10
  • Published
  • 95.1 kB
  • 1 dependency
  • MIT license

Install

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

Overview

TypeScript definitions for ioredis

Index

Variables

Interfaces

Type Aliases

Variables

variable IORedis

var IORedis: RedisStatic;

    Interfaces

    interface AddressFromResponse

    interface AddressFromResponse {}

      property flags

      flags?: string | undefined;

        property ip

        ip: string;

          property port

          port: string;

            interface Cluster

            interface Cluster extends EventEmitter, Commander, Commands {}

              property isCluster

              readonly isCluster: true;

                property options

                readonly options: ClusterOptions;

                  property status

                  readonly status: string;

                    method connect

                    connect: () => Promise<void>;

                      method disconnect

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

                        method duplicate

                        duplicate: (
                        overrideStartupNodes?: ReadonlyArray<ClusterNode>,
                        overrideOptions?: ClusterOptions
                        ) => Cluster;

                          method nodes

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

                            interface ClusterOptions

                            interface ClusterOptions {}

                              property dnsLookup

                              dnsLookup?: DNSLookupFunction | undefined;

                                property enableOfflineQueue

                                enableOfflineQueue?: boolean | undefined;

                                  property enableReadyCheck

                                  enableReadyCheck?: boolean | undefined;

                                    property lazyConnect

                                    lazyConnect?: boolean | undefined;

                                      property maxRedirections

                                      maxRedirections?: number | undefined;

                                        property natMap

                                        natMap?: NatMap | undefined;

                                          property redisOptions

                                          redisOptions?: RedisOptions | undefined;

                                            property retryDelayOnClusterDown

                                            retryDelayOnClusterDown?: number | undefined;

                                              property retryDelayOnFailover

                                              retryDelayOnFailover?: number | undefined;

                                                property retryDelayOnTryAgain

                                                retryDelayOnTryAgain?: number | undefined;

                                                  property scaleReads

                                                  scaleReads?: string | undefined;

                                                    property slotsRefreshInterval

                                                    slotsRefreshInterval?: number | undefined;

                                                      property slotsRefreshTimeout

                                                      slotsRefreshTimeout?: number | undefined;

                                                        method clusterRetryStrategy

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

                                                          interface ClusterStatic

                                                          interface ClusterStatic extends EventEmitter {}

                                                            construct signature

                                                            new (nodes: ClusterNode[], options?: ClusterOptions): Cluster;

                                                              interface Commands

                                                              interface Commands {}

                                                                property blpop

                                                                blpop: OverloadedBlockingListCommand<KeyType, [string, string]>;

                                                                  property brpop

                                                                  brpop: OverloadedBlockingListCommand<KeyType, [string, string]>;

                                                                    property bzpopmax

                                                                    bzpopmax: OverloadedBlockingListCommand<KeyType, [string, string, string]>;

                                                                      property bzpopmin

                                                                      bzpopmin: OverloadedBlockingListCommand<KeyType, [string, string, string]>;

                                                                        property client

                                                                        client: OverloadedSubCommand<ValueType, any>;

                                                                          property cluster

                                                                          cluster: OverloadedSubCommand<ValueType, any>;

                                                                            property debug

                                                                            debug: OverloadedSubCommand<ValueType, any>;

                                                                              property del

                                                                              del: OverloadedListCommand<KeyType, number>;

                                                                                property eval

                                                                                eval: OverloadedEvalCommand<ValueType, any>;

                                                                                  property evalsha

                                                                                  evalsha: OverloadedEvalCommand<ValueType, any>;

                                                                                    property geohash

                                                                                    geohash: OverloadedKeyCommand<string, string[]>;

                                                                                      property geopos

                                                                                      geopos: OverloadedKeyCommand<string, string[]>;

                                                                                        property hdel

                                                                                        hdel: OverloadedKeyCommand<KeyType, number>;

                                                                                          property hmget

                                                                                          hmget: OverloadedKeyCommand<KeyType, Array<string | null>>;

                                                                                            property hmgetBuffer

                                                                                            hmgetBuffer: OverloadedKeyCommand<KeyType, Array<Buffer | null>>;

                                                                                              property hmset

                                                                                              hmset: OverloadedKeyedHashCommand<ValueType, Ok>;

                                                                                                property hscan

                                                                                                hscan: OverloadedKeyCommand<ValueType, [string, string[]]>;

                                                                                                  property hset

                                                                                                  hset: OverloadedKeyedHashCommand<ValueType, number>;

                                                                                                    property lpush

                                                                                                    lpush: OverloadedKeyCommand<ValueType, number>;

                                                                                                      property lpushBuffer

                                                                                                      lpushBuffer: OverloadedKeyCommand<Buffer, number>;

                                                                                                        property lpushx

                                                                                                        lpushx: OverloadedKeyCommand<ValueType, number>;

                                                                                                          property mget

                                                                                                          mget: OverloadedListCommand<KeyType, Array<string | null>>;

                                                                                                            property mgetBuffer

                                                                                                            mgetBuffer: OverloadedListCommand<KeyType, Array<Buffer | null>>;

                                                                                                              property migrate

                                                                                                              migrate: OverloadedListCommand<ValueType, Ok | 'NOKEY'>;

                                                                                                                property mset

                                                                                                                mset: OverloadedHashCommand<ValueType, Ok>;

                                                                                                                  property msetBuffer

                                                                                                                  msetBuffer: OverloadedHashCommand<ValueType, Ok>;

                                                                                                                    property msetnx

                                                                                                                    msetnx: OverloadedHashCommand<ValueType, BooleanResponse>;

                                                                                                                      property object

                                                                                                                      object: OverloadedListCommand<ValueType, any>;

                                                                                                                        property pfadd

                                                                                                                        pfadd: OverloadedKeyCommand<string, number>;

                                                                                                                          property pfcount

                                                                                                                          pfcount: OverloadedListCommand<KeyType, number>;

                                                                                                                            property pfmerge

                                                                                                                            pfmerge: OverloadedKeyCommand<KeyType, Ok>;

                                                                                                                              property psubscribe

                                                                                                                              psubscribe: OverloadedListCommand<string, number>;

                                                                                                                                property punsubscribe

                                                                                                                                punsubscribe: OverloadedCommand<string, number>;

                                                                                                                                  property restore

                                                                                                                                  restore: OverloadedListCommand<ValueType, Ok>;

                                                                                                                                    property rpush

                                                                                                                                    rpush: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                      property rpushBuffer

                                                                                                                                      rpushBuffer: OverloadedKeyCommand<Buffer, number>;

                                                                                                                                        property rpushx

                                                                                                                                        rpushx: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                          property sadd

                                                                                                                                          sadd: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                            property script

                                                                                                                                            script: OverloadedSubCommand<ValueType, any>;

                                                                                                                                              property sdiff

                                                                                                                                              sdiff: OverloadedListCommand<KeyType, string[]>;

                                                                                                                                                property sdiffstore

                                                                                                                                                sdiffstore: OverloadedKeyCommand<KeyType, number>;

                                                                                                                                                  property sinter

                                                                                                                                                  sinter: OverloadedListCommand<KeyType, string[]>;

                                                                                                                                                    property sinterstore

                                                                                                                                                    sinterstore: OverloadedKeyCommand<KeyType, number>;

                                                                                                                                                      property sort

                                                                                                                                                      sort: OverloadedListCommand<KeyType | number, string[] | number>;

                                                                                                                                                        property srem

                                                                                                                                                        srem: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                                          property sscan

                                                                                                                                                          sscan: OverloadedKeyCommand<ValueType, [string, string[]]>;

                                                                                                                                                            property subscribe

                                                                                                                                                            subscribe: OverloadedListCommand<string, number>;

                                                                                                                                                              property sunion

                                                                                                                                                              sunion: OverloadedListCommand<KeyType, string[]>;

                                                                                                                                                                property sunionstore

                                                                                                                                                                sunionstore: OverloadedKeyCommand<KeyType, number>;
                                                                                                                                                                  unlink: OverloadedListCommand<KeyType, number>;

                                                                                                                                                                    property unsubscribe

                                                                                                                                                                    unsubscribe: OverloadedCommand<string, number>;

                                                                                                                                                                      property watch

                                                                                                                                                                      watch: OverloadedListCommand<KeyType, Ok>;

                                                                                                                                                                        property xack

                                                                                                                                                                        xack: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                                                          property xadd

                                                                                                                                                                          xadd: OverloadedKeyCommand<ValueType, string>;

                                                                                                                                                                            property xautoclaim

                                                                                                                                                                            xautoclaim: OverloadedSubCommand<ValueType, [string, Array<[string, string[]]>]>;

                                                                                                                                                                              property xclaim

                                                                                                                                                                              xclaim: OverloadedKeyCommand<ValueType, Array<[string, string[]]>>;

                                                                                                                                                                                property xdel

                                                                                                                                                                                xdel: OverloadedKeyCommand<string, number>;

                                                                                                                                                                                  property xgroup

                                                                                                                                                                                  xgroup: OverloadedSubCommand<ValueType, Ok | number>;

                                                                                                                                                                                    property xinfo

                                                                                                                                                                                    xinfo: OverloadedSubCommand<ValueType, any>;

                                                                                                                                                                                      property xpending

                                                                                                                                                                                      xpending: OverloadedKeyCommand<ValueType, any>;

                                                                                                                                                                                        property xrange

                                                                                                                                                                                        xrange: OverloadedKeyCommand<ValueType, Array<[string, string[]]>>;

                                                                                                                                                                                          property xread

                                                                                                                                                                                          xread: OverloadedListCommand<
                                                                                                                                                                                          ValueType,
                                                                                                                                                                                          Array<[string, Array<[string, string[]]>]>
                                                                                                                                                                                          >;

                                                                                                                                                                                            property xreadgroup

                                                                                                                                                                                            xreadgroup: OverloadedKeyCommand<
                                                                                                                                                                                            ValueType,
                                                                                                                                                                                            Array<[string, Array<[string, string[]]>]>
                                                                                                                                                                                            >;

                                                                                                                                                                                              property xrevrange

                                                                                                                                                                                              xrevrange: OverloadedKeyCommand<ValueType, Array<[string, string[]]>>;

                                                                                                                                                                                                property xtrim

                                                                                                                                                                                                xtrim: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                                                                                  property zadd

                                                                                                                                                                                                  zadd: OverloadedKeyCommand<KeyType | number, number | string>;

                                                                                                                                                                                                    property zinterstore

                                                                                                                                                                                                    zinterstore: OverloadedKeyCommand<KeyType | number, number>;

                                                                                                                                                                                                      property zmscore

                                                                                                                                                                                                      zmscore: OverloadedKeyCommand<KeyType, Array<string | null>>;

                                                                                                                                                                                                        property zrem

                                                                                                                                                                                                        zrem: OverloadedKeyCommand<ValueType, number>;

                                                                                                                                                                                                          property zscan

                                                                                                                                                                                                          zscan: OverloadedKeyCommand<ValueType, [string, string[]]>;

                                                                                                                                                                                                            property zunionstore

                                                                                                                                                                                                            zunionstore: OverloadedKeyCommand<KeyType | number, number>;

                                                                                                                                                                                                              method append

                                                                                                                                                                                                              append: {
                                                                                                                                                                                                              (key: KeyType, value: ValueType, callback: Callback<number>): void;
                                                                                                                                                                                                              (key: any, value: any): Promise<number>;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                method auth

                                                                                                                                                                                                                auth: {
                                                                                                                                                                                                                (username: string, password: string, callback: Callback<string>): void;
                                                                                                                                                                                                                (password: string, callback: Callback<string>): void;
                                                                                                                                                                                                                (username: string, password: string): Promise<string>;
                                                                                                                                                                                                                (password: string): Promise<string>;
                                                                                                                                                                                                                };

                                                                                                                                                                                                                  method bgrewriteaof

                                                                                                                                                                                                                  bgrewriteaof: { (callback: Callback<string>): void; (): Promise<string> };

                                                                                                                                                                                                                    method bgsave

                                                                                                                                                                                                                    bgsave: { (callback: Callback<string>): void; (): Promise<string> };

                                                                                                                                                                                                                      method bitcount

                                                                                                                                                                                                                      bitcount: {
                                                                                                                                                                                                                      (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                      (
                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                      start: number,
                                                                                                                                                                                                                      end: number,
                                                                                                                                                                                                                      callback: (err: Error, res: number) => void
                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                      (key: any): Promise<number>;
                                                                                                                                                                                                                      (key: any, start: number, end: number): Promise<number>;
                                                                                                                                                                                                                      };

                                                                                                                                                                                                                        method bitfield

                                                                                                                                                                                                                        bitfield: {
                                                                                                                                                                                                                        (key: KeyType, args: ValueType, callback: Callback<number[]>): void;
                                                                                                                                                                                                                        (key: any, args: any): Promise<number[]>;
                                                                                                                                                                                                                        };

                                                                                                                                                                                                                          method blmove

                                                                                                                                                                                                                          blmove: {
                                                                                                                                                                                                                          (
                                                                                                                                                                                                                          source: KeyType,
                                                                                                                                                                                                                          destination: KeyType,
                                                                                                                                                                                                                          whereFrom: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                          whereTo: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                          timeout: number,
                                                                                                                                                                                                                          callback: Callback<string | null>
                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                          (
                                                                                                                                                                                                                          source: any,
                                                                                                                                                                                                                          destination: any,
                                                                                                                                                                                                                          whereFrom: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                          whereTo: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                          timeout: number
                                                                                                                                                                                                                          ): Promise<string>;
                                                                                                                                                                                                                          };

                                                                                                                                                                                                                            method brpoplpush

                                                                                                                                                                                                                            brpoplpush: {
                                                                                                                                                                                                                            (
                                                                                                                                                                                                                            source: string,
                                                                                                                                                                                                                            destination: string,
                                                                                                                                                                                                                            timeout: number,
                                                                                                                                                                                                                            callback: Callback<string>
                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                            (source: string, destination: string, timeout: number): Promise<string>;
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              method config

                                                                                                                                                                                                                              config: {
                                                                                                                                                                                                                              (op: 'GET', cfg: string): Promise<string[]>;
                                                                                                                                                                                                                              (op: 'GET', cfg: string, callback: Callback<string[]>): void;
                                                                                                                                                                                                                              (op: 'REWRITE' | 'RESETSTAT'): Promise<'OK'>;
                                                                                                                                                                                                                              (op: 'REWRITE' | 'RESETSTAT', callback: Callback<'OK'>): void;
                                                                                                                                                                                                                              (op: 'SET', key: string, value: any): Promise<'OK'>;
                                                                                                                                                                                                                              (op: 'SET', key: string, value: any, callback: Callback<'OK'>): void;
                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                method dbsize

                                                                                                                                                                                                                                dbsize: { (callback: Callback<number>): void; (): Promise<number> };

                                                                                                                                                                                                                                  method decr

                                                                                                                                                                                                                                  decr: {
                                                                                                                                                                                                                                  (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                  (key: any): Promise<number>;
                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                    method decrby

                                                                                                                                                                                                                                    decrby: {
                                                                                                                                                                                                                                    (key: KeyType, decrement: number, callback: Callback<number>): void;
                                                                                                                                                                                                                                    (key: any, decrement: number): Promise<number>;
                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                      method discard

                                                                                                                                                                                                                                      discard: { (callback: Callback<Ok>): void; (): Promise<'OK'> };

                                                                                                                                                                                                                                        method dump

                                                                                                                                                                                                                                        dump: {
                                                                                                                                                                                                                                        (key: KeyType, callback: Callback<string>): void;
                                                                                                                                                                                                                                        (key: any): Promise<string>;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          method echo

                                                                                                                                                                                                                                          echo: {
                                                                                                                                                                                                                                          (message: string, callback: Callback<string>): void;
                                                                                                                                                                                                                                          (message: string): Promise<string>;
                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                            method exec

                                                                                                                                                                                                                                            exec: {
                                                                                                                                                                                                                                            (callback: Callback<Array<[Error | null, string]>>): void;
                                                                                                                                                                                                                                            (): Promise<[Error, string][]>;
                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                              method exists

                                                                                                                                                                                                                                              exists: {
                                                                                                                                                                                                                                              (...keys: KeyType[]): Promise<number>;
                                                                                                                                                                                                                                              (key: any, callback: Callback<number>): void;
                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                method expire

                                                                                                                                                                                                                                                expire: {
                                                                                                                                                                                                                                                (key: KeyType, seconds: number, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                (key: any, seconds: number): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                  method expireat

                                                                                                                                                                                                                                                  expireat: {
                                                                                                                                                                                                                                                  (key: KeyType, timestamp: number, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                  (key: any, timestamp: number): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                    method flushall

                                                                                                                                                                                                                                                    flushall: { (callback: Callback<Ok>): void; (): Promise<'OK'> };

                                                                                                                                                                                                                                                      method flushdb

                                                                                                                                                                                                                                                      flushdb: {
                                                                                                                                                                                                                                                      (callback: Callback<Ok>): void;
                                                                                                                                                                                                                                                      (option?: 'async' | 'sync'): Promise<'OK'>;
                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                        method geoadd

                                                                                                                                                                                                                                                        geoadd: {
                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                        key: KeyType,
                                                                                                                                                                                                                                                        longitude: number,
                                                                                                                                                                                                                                                        latitude: number,
                                                                                                                                                                                                                                                        member: string,
                                                                                                                                                                                                                                                        callback: Callback<number>
                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                        longitude: number,
                                                                                                                                                                                                                                                        latitude: number,
                                                                                                                                                                                                                                                        member: string
                                                                                                                                                                                                                                                        ): Promise<number>;
                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                          method geodist

                                                                                                                                                                                                                                                          geodist: {
                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                          member1: string,
                                                                                                                                                                                                                                                          member2: string,
                                                                                                                                                                                                                                                          unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                          callback: Callback<string | null>
                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                          member1: string,
                                                                                                                                                                                                                                                          member2: string,
                                                                                                                                                                                                                                                          unit: 'm' | 'km' | 'ft' | 'mi'
                                                                                                                                                                                                                                                          ): Promise<string>;
                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                            method georadius

                                                                                                                                                                                                                                                            georadius: {
                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                            longitude: number,
                                                                                                                                                                                                                                                            latitude: number,
                                                                                                                                                                                                                                                            radius: number,
                                                                                                                                                                                                                                                            unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                            callback: Callback<string[]>
                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                            key: any,
                                                                                                                                                                                                                                                            longitude: number,
                                                                                                                                                                                                                                                            latitude: number,
                                                                                                                                                                                                                                                            radius: number,
                                                                                                                                                                                                                                                            unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                            sort?: 'ASC' | 'DESC'
                                                                                                                                                                                                                                                            ): Promise<string[]>;
                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                            key: any,
                                                                                                                                                                                                                                                            longitude: number,
                                                                                                                                                                                                                                                            latitude: number,
                                                                                                                                                                                                                                                            radius: number,
                                                                                                                                                                                                                                                            unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                            count: 'COUNT',
                                                                                                                                                                                                                                                            countValue: number,
                                                                                                                                                                                                                                                            sort?: 'ASC' | 'DESC'
                                                                                                                                                                                                                                                            ): Promise<string[]>;
                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                              method georadiusbymember

                                                                                                                                                                                                                                                              georadiusbymember: {
                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                              key: KeyType,
                                                                                                                                                                                                                                                              member: string,
                                                                                                                                                                                                                                                              radius: number,
                                                                                                                                                                                                                                                              unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                              callback: Callback<string[]>
                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                              key: any,
                                                                                                                                                                                                                                                              member: string,
                                                                                                                                                                                                                                                              radius: number,
                                                                                                                                                                                                                                                              unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                              count: 'COUNT',
                                                                                                                                                                                                                                                              countValue: number,
                                                                                                                                                                                                                                                              callback: Callback<string[]>
                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                              key: any,
                                                                                                                                                                                                                                                              member: string,
                                                                                                                                                                                                                                                              radius: number,
                                                                                                                                                                                                                                                              unit: 'm' | 'km' | 'ft' | 'mi'
                                                                                                                                                                                                                                                              ): Promise<string[]>;
                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                              key: any,
                                                                                                                                                                                                                                                              member: string,
                                                                                                                                                                                                                                                              radius: number,
                                                                                                                                                                                                                                                              unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                              count: 'COUNT',
                                                                                                                                                                                                                                                              countValue: number
                                                                                                                                                                                                                                                              ): Promise<string[]>;
                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                method geosearch

                                                                                                                                                                                                                                                                geosearch: {
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: KeyType,
                                                                                                                                                                                                                                                                from: 'FROMMEMBER',
                                                                                                                                                                                                                                                                member: string,
                                                                                                                                                                                                                                                                by: 'BYRADIUS',
                                                                                                                                                                                                                                                                radius: number,
                                                                                                                                                                                                                                                                radiusUnit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                count: 'COUNT',
                                                                                                                                                                                                                                                                countValue: number,
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | Array<string[] | string[][]>>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMMEMBER',
                                                                                                                                                                                                                                                                member: string,
                                                                                                                                                                                                                                                                by: 'BYBOX',
                                                                                                                                                                                                                                                                width: number,
                                                                                                                                                                                                                                                                height: number,
                                                                                                                                                                                                                                                                unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                count: 'COUNT',
                                                                                                                                                                                                                                                                countValue: number,
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMLONLAT',
                                                                                                                                                                                                                                                                longitude: number,
                                                                                                                                                                                                                                                                latitude: number,
                                                                                                                                                                                                                                                                by: 'BYRADIUS',
                                                                                                                                                                                                                                                                radius: number,
                                                                                                                                                                                                                                                                radiusUnit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                count: 'COUNT',
                                                                                                                                                                                                                                                                countValue: number,
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMLONLAT',
                                                                                                                                                                                                                                                                longitude: number,
                                                                                                                                                                                                                                                                latitude: number,
                                                                                                                                                                                                                                                                by: 'BYBOX',
                                                                                                                                                                                                                                                                width: number,
                                                                                                                                                                                                                                                                height: number,
                                                                                                                                                                                                                                                                unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                count: 'COUNT',
                                                                                                                                                                                                                                                                countValue: number,
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMMEMBER',
                                                                                                                                                                                                                                                                member: string,
                                                                                                                                                                                                                                                                by: 'BYRADIUS',
                                                                                                                                                                                                                                                                radius: number,
                                                                                                                                                                                                                                                                radiusUnit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMMEMBER',
                                                                                                                                                                                                                                                                member: string,
                                                                                                                                                                                                                                                                by: 'BYBOX',
                                                                                                                                                                                                                                                                width: number,
                                                                                                                                                                                                                                                                height: number,
                                                                                                                                                                                                                                                                unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMLONLAT',
                                                                                                                                                                                                                                                                longitude: number,
                                                                                                                                                                                                                                                                latitude: number,
                                                                                                                                                                                                                                                                by: 'BYRADIUS',
                                                                                                                                                                                                                                                                radius: number,
                                                                                                                                                                                                                                                                radiusUnit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                from: 'FROMLONLAT',
                                                                                                                                                                                                                                                                longitude: number,
                                                                                                                                                                                                                                                                latitude: number,
                                                                                                                                                                                                                                                                by: 'BYBOX',
                                                                                                                                                                                                                                                                width: number,
                                                                                                                                                                                                                                                                height: number,
                                                                                                                                                                                                                                                                unit: 'm' | 'km' | 'ft' | 'mi',
                                                                                                                                                                                                                                                                sort?: 'ASC' | 'DESC',
                                                                                                                                                                                                                                                                withCoord?: 'WITHCOORD',
                                                                                                                                                                                                                                                                withDist?: 'WITHDIST',
                                                                                                                                                                                                                                                                withHash?: 'WITHHASH'
                                                                                                                                                                                                                                                                ): Promise<string[] | (string[] | string[][])[]>;
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                • https://redis.io/commands/geosearch

                                                                                                                                                                                                                                                                method get

                                                                                                                                                                                                                                                                get: {
                                                                                                                                                                                                                                                                (key: KeyType, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                (key: any): Promise<string>;
                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                  method getbit

                                                                                                                                                                                                                                                                  getbit: {
                                                                                                                                                                                                                                                                  (key: KeyType, offset: number, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                  (key: any, offset: number): Promise<number>;
                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                    method getBuffer

                                                                                                                                                                                                                                                                    getBuffer: {
                                                                                                                                                                                                                                                                    (key: KeyType, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                    (key: any): Promise<Buffer>;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      method getdel

                                                                                                                                                                                                                                                                      getdel: {
                                                                                                                                                                                                                                                                      (key: KeyType, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                      (key: any): Promise<string>;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        method getex

                                                                                                                                                                                                                                                                        getex: {
                                                                                                                                                                                                                                                                        (key: KeyType, expiryMode?: string, time?: number | string): Promise<
                                                                                                                                                                                                                                                                        string | null
                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                        (key: any, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                        expiryMode: string,
                                                                                                                                                                                                                                                                        time: string | number,
                                                                                                                                                                                                                                                                        callback: Callback<string>
                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                          method getrange

                                                                                                                                                                                                                                                                          getrange: {
                                                                                                                                                                                                                                                                          (key: KeyType, start: number, end: number, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                          (key: any, start: number, end: number): Promise<string>;
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            method getrangeBuffer

                                                                                                                                                                                                                                                                            getrangeBuffer: {
                                                                                                                                                                                                                                                                            (key: KeyType, start: number, end: number, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                            (key: any, start: number, end: number): Promise<Buffer>;
                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                              method getset

                                                                                                                                                                                                                                                                              getset: {
                                                                                                                                                                                                                                                                              (key: KeyType, value: ValueType, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                              (key: any, value: any): Promise<string>;
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                method hexists

                                                                                                                                                                                                                                                                                hexists: {
                                                                                                                                                                                                                                                                                (key: KeyType, field: string, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                                                (key: any, field: string): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  method hget

                                                                                                                                                                                                                                                                                  hget: {
                                                                                                                                                                                                                                                                                  (key: KeyType, field: string, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                                  (key: any, field: string): Promise<string>;
                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                    method hgetall

                                                                                                                                                                                                                                                                                    hgetall: {
                                                                                                                                                                                                                                                                                    (key: KeyType, callback: Callback<Record<string, string>>): void;
                                                                                                                                                                                                                                                                                    (key: any): Promise<Record<string, string>>;
                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                      method hgetBuffer

                                                                                                                                                                                                                                                                                      hgetBuffer: {
                                                                                                                                                                                                                                                                                      (key: KeyType, field: string, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                                      (key: any, field: string): Promise<Buffer>;
                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                        method hincrby

                                                                                                                                                                                                                                                                                        hincrby: {
                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                        key: KeyType,
                                                                                                                                                                                                                                                                                        field: string,
                                                                                                                                                                                                                                                                                        increment: number,
                                                                                                                                                                                                                                                                                        callback: Callback<number>
                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                        (key: any, field: string, increment: number): Promise<number>;
                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                          method hincrbyfloat

                                                                                                                                                                                                                                                                                          hincrbyfloat: {
                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                                                          field: string,
                                                                                                                                                                                                                                                                                          increment: number,
                                                                                                                                                                                                                                                                                          callback: Callback<number>
                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                          (key: any, field: string, increment: number): Promise<number>;
                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                            method hkeys

                                                                                                                                                                                                                                                                                            hkeys: {
                                                                                                                                                                                                                                                                                            (key: KeyType, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                            (key: any): Promise<string[]>;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              method hlen

                                                                                                                                                                                                                                                                                              hlen: {
                                                                                                                                                                                                                                                                                              (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                              (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                method hscanStream

                                                                                                                                                                                                                                                                                                hscanStream: (key: KeyType, options?: ScanStreamOption) => Readable;

                                                                                                                                                                                                                                                                                                  method hsetBuffer

                                                                                                                                                                                                                                                                                                  hsetBuffer: {
                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                  key: KeyType,
                                                                                                                                                                                                                                                                                                  field: string,
                                                                                                                                                                                                                                                                                                  value: ValueType,
                                                                                                                                                                                                                                                                                                  callback: Callback<BooleanResponse>
                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                  (key: any, field: string, value: any): Promise<Buffer>;
                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                    method hsetnx

                                                                                                                                                                                                                                                                                                    hsetnx: {
                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                    key: KeyType,
                                                                                                                                                                                                                                                                                                    field: string,
                                                                                                                                                                                                                                                                                                    value: ValueType,
                                                                                                                                                                                                                                                                                                    callback: Callback<BooleanResponse>
                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                    (key: any, field: string, value: any): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                      method hstrlen

                                                                                                                                                                                                                                                                                                      hstrlen: {
                                                                                                                                                                                                                                                                                                      (key: KeyType, field: string, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                      (key: any, field: string): Promise<number>;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        method hvals

                                                                                                                                                                                                                                                                                                        hvals: {
                                                                                                                                                                                                                                                                                                        (key: KeyType, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                        (key: any): Promise<string[]>;
                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                          method incr

                                                                                                                                                                                                                                                                                                          incr: {
                                                                                                                                                                                                                                                                                                          (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                          (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                            method incrby

                                                                                                                                                                                                                                                                                                            incrby: {
                                                                                                                                                                                                                                                                                                            (key: KeyType, increment: number, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                            (key: any, increment: number): Promise<number>;
                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                              method incrbyfloat

                                                                                                                                                                                                                                                                                                              incrbyfloat: {
                                                                                                                                                                                                                                                                                                              (key: KeyType, increment: number, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                              (key: any, increment: number): Promise<number>;
                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                method info

                                                                                                                                                                                                                                                                                                                info: {
                                                                                                                                                                                                                                                                                                                (callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                (section: string, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                (section?: string): Promise<string>;
                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                  method keys

                                                                                                                                                                                                                                                                                                                  keys: {
                                                                                                                                                                                                                                                                                                                  (pattern: string, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                  (pattern: string): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                    method lastsave

                                                                                                                                                                                                                                                                                                                    lastsave: { (callback: Callback<number>): void; (): Promise<number> };

                                                                                                                                                                                                                                                                                                                      method lindex

                                                                                                                                                                                                                                                                                                                      lindex: {
                                                                                                                                                                                                                                                                                                                      (key: KeyType, index: number, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                      (key: any, index: number): Promise<string>;
                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                        method lindexBuffer

                                                                                                                                                                                                                                                                                                                        lindexBuffer: {
                                                                                                                                                                                                                                                                                                                        (key: KeyType, index: number, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                                                                        (key: any, index: number): Promise<Buffer>;
                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                          method linsert

                                                                                                                                                                                                                                                                                                                          linsert: {
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                                                                                          direction: 'BEFORE' | 'AFTER',
                                                                                                                                                                                                                                                                                                                          pivot: string,
                                                                                                                                                                                                                                                                                                                          value: ValueType,
                                                                                                                                                                                                                                                                                                                          callback: Callback<number>
                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                          direction: 'BEFORE' | 'AFTER',
                                                                                                                                                                                                                                                                                                                          pivot: string,
                                                                                                                                                                                                                                                                                                                          value: any
                                                                                                                                                                                                                                                                                                                          ): Promise<number>;
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            method llen

                                                                                                                                                                                                                                                                                                                            llen: {
                                                                                                                                                                                                                                                                                                                            (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                            (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                              method lmove

                                                                                                                                                                                                                                                                                                                              lmove: {
                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                              source: KeyType,
                                                                                                                                                                                                                                                                                                                              destination: KeyType,
                                                                                                                                                                                                                                                                                                                              whereFrom: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                                                                                                                              whereTo: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                                                                                                                              callback: Callback<string | null>
                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                              source: any,
                                                                                                                                                                                                                                                                                                                              destination: any,
                                                                                                                                                                                                                                                                                                                              whereFrom: 'LEFT' | 'RIGHT',
                                                                                                                                                                                                                                                                                                                              whereTo: 'LEFT' | 'RIGHT'
                                                                                                                                                                                                                                                                                                                              ): Promise<string>;
                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                method lpop

                                                                                                                                                                                                                                                                                                                                lpop: {
                                                                                                                                                                                                                                                                                                                                (key: KeyType, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                (key: any): Promise<string>;
                                                                                                                                                                                                                                                                                                                                (key: any, count: number, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                (key: any, count: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                  method lpopBuffer

                                                                                                                                                                                                                                                                                                                                  lpopBuffer: {
                                                                                                                                                                                                                                                                                                                                  (key: KeyType, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                                                                                  (key: any): Promise<Buffer>;
                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                    method lpos

                                                                                                                                                                                                                                                                                                                                    lpos: (
                                                                                                                                                                                                                                                                                                                                    key: KeyType,
                                                                                                                                                                                                                                                                                                                                    value: ValueType,
                                                                                                                                                                                                                                                                                                                                    rank?: number,
                                                                                                                                                                                                                                                                                                                                    count?: number,
                                                                                                                                                                                                                                                                                                                                    maxlen?: number
                                                                                                                                                                                                                                                                                                                                    ) => Promise<number | null>;

                                                                                                                                                                                                                                                                                                                                      method lrange

                                                                                                                                                                                                                                                                                                                                      lrange: {
                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                      key: KeyType,
                                                                                                                                                                                                                                                                                                                                      start: number,
                                                                                                                                                                                                                                                                                                                                      stop: number,
                                                                                                                                                                                                                                                                                                                                      callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                      (key: any, start: number, stop: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                        method lrangeBuffer

                                                                                                                                                                                                                                                                                                                                        lrangeBuffer: {
                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                        key: KeyType,
                                                                                                                                                                                                                                                                                                                                        start: number,
                                                                                                                                                                                                                                                                                                                                        stop: number,
                                                                                                                                                                                                                                                                                                                                        callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                        (key: any, start: number, stop: number): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                          method lrem

                                                                                                                                                                                                                                                                                                                                          lrem: {
                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                          value: ValueType,
                                                                                                                                                                                                                                                                                                                                          callback: Callback<number>
                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                          (key: any, count: number, value: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                            method lset

                                                                                                                                                                                                                                                                                                                                            lset: {
                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                                                                                                            index: number,
                                                                                                                                                                                                                                                                                                                                            value: ValueType,
                                                                                                                                                                                                                                                                                                                                            callback: Callback<Ok>
                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                            (key: any, index: number, value: any): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              method ltrim

                                                                                                                                                                                                                                                                                                                                              ltrim: {
                                                                                                                                                                                                                                                                                                                                              (key: KeyType, start: number, stop: number, callback: Callback<Ok>): void;
                                                                                                                                                                                                                                                                                                                                              (key: any, start: number, stop: number): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                method memory

                                                                                                                                                                                                                                                                                                                                                memory: (
                                                                                                                                                                                                                                                                                                                                                argument: 'USAGE',
                                                                                                                                                                                                                                                                                                                                                key: KeyType,
                                                                                                                                                                                                                                                                                                                                                callback?: Callback<number>
                                                                                                                                                                                                                                                                                                                                                ) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                  method monitor

                                                                                                                                                                                                                                                                                                                                                  monitor: { (callback: Callback<EventEmitter>): void; (): Promise<EventEmitter> };

                                                                                                                                                                                                                                                                                                                                                    method move

                                                                                                                                                                                                                                                                                                                                                    move: {
                                                                                                                                                                                                                                                                                                                                                    (key: KeyType, db: string, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                                                                                                                    (key: any, db: string): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                      method multi

                                                                                                                                                                                                                                                                                                                                                      multi: {
                                                                                                                                                                                                                                                                                                                                                      (commands?: string[][], options?: MultiOptions): Pipeline;
                                                                                                                                                                                                                                                                                                                                                      (options: { pipeline: false }): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        method persist

                                                                                                                                                                                                                                                                                                                                                        persist: {
                                                                                                                                                                                                                                                                                                                                                        (key: KeyType, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                                                                                                                        (key: any): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                          method pexpire

                                                                                                                                                                                                                                                                                                                                                          pexpire: {
                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                                                                                                                          milliseconds: number,
                                                                                                                                                                                                                                                                                                                                                          callback: Callback<BooleanResponse>
                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                          (key: any, milliseconds: number): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                            method pexpireat

                                                                                                                                                                                                                                                                                                                                                            pexpireat: {
                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                                                                                                                            millisecondsTimestamp: number,
                                                                                                                                                                                                                                                                                                                                                            callback: Callback<BooleanResponse>
                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                            (key: any, millisecondsTimestamp: number): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                              method ping

                                                                                                                                                                                                                                                                                                                                                              ping: {
                                                                                                                                                                                                                                                                                                                                                              (callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                              (message: string, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                              (message?: string): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                method pipeline

                                                                                                                                                                                                                                                                                                                                                                pipeline: (commands?: string[][]) => Pipeline;

                                                                                                                                                                                                                                                                                                                                                                  method psetex

                                                                                                                                                                                                                                                                                                                                                                  psetex: {
                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                  key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                  milliseconds: number,
                                                                                                                                                                                                                                                                                                                                                                  value: ValueType,
                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<Ok>
                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                  (key: any, milliseconds: number, value: any): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    method pttl

                                                                                                                                                                                                                                                                                                                                                                    pttl: {
                                                                                                                                                                                                                                                                                                                                                                    (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                    (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                      method publish

                                                                                                                                                                                                                                                                                                                                                                      publish: {
                                                                                                                                                                                                                                                                                                                                                                      (channel: string, message: string, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                      (channel: string, message: string): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                        method publishBuffer

                                                                                                                                                                                                                                                                                                                                                                        publishBuffer: (channel: string, message: Buffer) => Promise<number>;

                                                                                                                                                                                                                                                                                                                                                                          method quit

                                                                                                                                                                                                                                                                                                                                                                          quit: { (callback: Callback<Ok>): void; (): Promise<'OK'> };

                                                                                                                                                                                                                                                                                                                                                                            method randomkey

                                                                                                                                                                                                                                                                                                                                                                            randomkey: { (callback: Callback<string>): void; (): Promise<string> };

                                                                                                                                                                                                                                                                                                                                                                              method rename

                                                                                                                                                                                                                                                                                                                                                                              rename: {
                                                                                                                                                                                                                                                                                                                                                                              (key: KeyType, newkey: KeyType, callback: Callback<Ok>): void;
                                                                                                                                                                                                                                                                                                                                                                              (key: any, newkey: any): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                method renamenx

                                                                                                                                                                                                                                                                                                                                                                                renamenx: {
                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, newkey: KeyType, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                                                                                                                                                (key: any, newkey: any): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                  method rpop

                                                                                                                                                                                                                                                                                                                                                                                  rpop: {
                                                                                                                                                                                                                                                                                                                                                                                  (key: KeyType, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                                                  (key: any): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                  (key: any, count: number, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                  (key: any, count: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                    method rpoplpush

                                                                                                                                                                                                                                                                                                                                                                                    rpoplpush: {
                                                                                                                                                                                                                                                                                                                                                                                    (source: string, destination: string, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                                                    (source: string, destination: string): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                      method rpoplpushBuffer

                                                                                                                                                                                                                                                                                                                                                                                      rpoplpushBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                      (source: string, destination: string, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                                                                                                                                      (source: string, destination: string): Promise<Buffer>;
                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                        method save

                                                                                                                                                                                                                                                                                                                                                                                        save: { (callback: Callback<string>): void; (): Promise<string> };

                                                                                                                                                                                                                                                                                                                                                                                          method scan

                                                                                                                                                                                                                                                                                                                                                                                          scan: {
                                                                                                                                                                                                                                                                                                                                                                                          (cursor: number | string): Promise<[string, string[]]>;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          matchOption: 'match' | 'MATCH',
                                                                                                                                                                                                                                                                                                                                                                                          pattern: string
                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<[string, string[]]>;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          matchOption: 'match' | 'MATCH',
                                                                                                                                                                                                                                                                                                                                                                                          pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<[string, string[]]>
                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          countOption: 'COUNT' | 'count',
                                                                                                                                                                                                                                                                                                                                                                                          count: number
                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<[string, string[]]>;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          countOption: 'COUNT' | 'count',
                                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<[string, string[]]>
                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          matchOption: 'match' | 'MATCH',
                                                                                                                                                                                                                                                                                                                                                                                          pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                          countOption: 'COUNT' | 'count',
                                                                                                                                                                                                                                                                                                                                                                                          count: number
                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<[string, string[]]>;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          matchOption: 'match' | 'MATCH',
                                                                                                                                                                                                                                                                                                                                                                                          pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                          countOption: 'COUNT' | 'count',
                                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<[string, string[]]>
                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          countOption: 'COUNT' | 'count',
                                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                                          matchOption: 'match' | 'MATCH',
                                                                                                                                                                                                                                                                                                                                                                                          pattern: string
                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<[string, string[]]>;
                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                          cursor: string | number,
                                                                                                                                                                                                                                                                                                                                                                                          countOption: 'COUNT' | 'count',
                                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                                          matchOption: 'match' | 'MATCH',
                                                                                                                                                                                                                                                                                                                                                                                          pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<[string, string[]]>
                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                            method scanStream

                                                                                                                                                                                                                                                                                                                                                                                            scanStream: (options?: ScanStreamOption) => Readable;

                                                                                                                                                                                                                                                                                                                                                                                              method scard

                                                                                                                                                                                                                                                                                                                                                                                              scard: {
                                                                                                                                                                                                                                                                                                                                                                                              (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                                              (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                method select

                                                                                                                                                                                                                                                                                                                                                                                                select: {
                                                                                                                                                                                                                                                                                                                                                                                                (index: number, callback: Callback<Ok>): void;
                                                                                                                                                                                                                                                                                                                                                                                                (index: number): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                  method set

                                                                                                                                                                                                                                                                                                                                                                                                  set: {
                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                  key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                  value: ValueType,
                                                                                                                                                                                                                                                                                                                                                                                                  expiryMode?: string | any[],
                                                                                                                                                                                                                                                                                                                                                                                                  time?: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                  setMode?: number | string
                                                                                                                                                                                                                                                                                                                                                                                                  ): Promise<Ok | null>;
                                                                                                                                                                                                                                                                                                                                                                                                  (key: any, value: any, callback: Callback<'OK'>): void;
                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                  key: any,
                                                                                                                                                                                                                                                                                                                                                                                                  value: any,
                                                                                                                                                                                                                                                                                                                                                                                                  setMode: string | any[],
                                                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                  key: any,
                                                                                                                                                                                                                                                                                                                                                                                                  value: any,
                                                                                                                                                                                                                                                                                                                                                                                                  expiryMode: string,
                                                                                                                                                                                                                                                                                                                                                                                                  time: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                  key: any,
                                                                                                                                                                                                                                                                                                                                                                                                  value: any,
                                                                                                                                                                                                                                                                                                                                                                                                  expiryMode: string,
                                                                                                                                                                                                                                                                                                                                                                                                  time: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                  setMode: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<'OK'>
                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                    method setbit

                                                                                                                                                                                                                                                                                                                                                                                                    setbit: {
                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                    key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                    value: ValueType,
                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                    (key: any, offset: number, value: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                      method setBuffer

                                                                                                                                                                                                                                                                                                                                                                                                      setBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                      key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                      value: ValueType,
                                                                                                                                                                                                                                                                                                                                                                                                      expiryMode?: string | any[],
                                                                                                                                                                                                                                                                                                                                                                                                      time?: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                      setMode?: number | string
                                                                                                                                                                                                                                                                                                                                                                                                      ): Promise<Buffer>;
                                                                                                                                                                                                                                                                                                                                                                                                      (key: any, value: any, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                                                                                                                                                      (key: any, value: any, setMode: string, callback: Callback<Buffer>): void;
                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                      value: any,
                                                                                                                                                                                                                                                                                                                                                                                                      expiryMode: string,
                                                                                                                                                                                                                                                                                                                                                                                                      time: number,
                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer>
                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                      value: any,
                                                                                                                                                                                                                                                                                                                                                                                                      expiryMode: string,
                                                                                                                                                                                                                                                                                                                                                                                                      time: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                      setMode: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer>
                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                        method setex

                                                                                                                                                                                                                                                                                                                                                                                                        setex: {
                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                        key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                        seconds: number,
                                                                                                                                                                                                                                                                                                                                                                                                        value: ValueType,
                                                                                                                                                                                                                                                                                                                                                                                                        callback: Callback<Ok>
                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                        (key: any, seconds: number, value: any): Promise<'OK'>;
                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                          method setnx

                                                                                                                                                                                                                                                                                                                                                                                                          setnx: {
                                                                                                                                                                                                                                                                                                                                                                                                          (key: KeyType, value: ValueType, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                                                                                                                                                                          (key: any, value: any): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                            method setrange

                                                                                                                                                                                                                                                                                                                                                                                                            setrange: {
                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                            offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                            value: ValueType,
                                                                                                                                                                                                                                                                                                                                                                                                            callback: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                                                                            (key: any, offset: number, value: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                              method shutdown

                                                                                                                                                                                                                                                                                                                                                                                                              shutdown: {
                                                                                                                                                                                                                                                                                                                                                                                                              (save: 'SAVE' | 'NOSAVE', callback: Callback<never>): void;
                                                                                                                                                                                                                                                                                                                                                                                                              (save: 'SAVE' | 'NOSAVE'): Promise<never>;
                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                method sismember

                                                                                                                                                                                                                                                                                                                                                                                                                sismember: {
                                                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, member: string, callback: Callback<BooleanResponse>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                (key: any, member: string): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                  method slaveof

                                                                                                                                                                                                                                                                                                                                                                                                                  slaveof: {
                                                                                                                                                                                                                                                                                                                                                                                                                  (host: string, port: number, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                  (host: string, port: number): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                    method smembers

                                                                                                                                                                                                                                                                                                                                                                                                                    smembers: {
                                                                                                                                                                                                                                                                                                                                                                                                                    (key: KeyType, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                    (key: any): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                      method smismember

                                                                                                                                                                                                                                                                                                                                                                                                                      smismember: (key: KeyType, ...members: string[]) => Promise<BooleanResponse[]>;

                                                                                                                                                                                                                                                                                                                                                                                                                        method smove

                                                                                                                                                                                                                                                                                                                                                                                                                        smove: {
                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                        source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                        destination: string,
                                                                                                                                                                                                                                                                                                                                                                                                                        member: string,
                                                                                                                                                                                                                                                                                                                                                                                                                        callback: Callback<BooleanResponse>
                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                        source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                        destination: string,
                                                                                                                                                                                                                                                                                                                                                                                                                        member: string
                                                                                                                                                                                                                                                                                                                                                                                                                        ): Promise<BooleanResponse>;
                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                          method spop

                                                                                                                                                                                                                                                                                                                                                                                                                          spop: {
                                                                                                                                                                                                                                                                                                                                                                                                                          (key: KeyType, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any, count: number, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any, count: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                            method srandmember

                                                                                                                                                                                                                                                                                                                                                                                                                            srandmember: {
                                                                                                                                                                                                                                                                                                                                                                                                                            (key: KeyType, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                            (key: any): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                            (key: any, count: number, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                            (key: any, count: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                              method sscanStream

                                                                                                                                                                                                                                                                                                                                                                                                                              sscanStream: (key: KeyType, options?: ScanStreamOption) => Readable;

                                                                                                                                                                                                                                                                                                                                                                                                                                method strlen

                                                                                                                                                                                                                                                                                                                                                                                                                                strlen: {
                                                                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                  method substr

                                                                                                                                                                                                                                                                                                                                                                                                                                  substr: {
                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: KeyType, start: number, end: number, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: any, start: number, end: number): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                    method sync

                                                                                                                                                                                                                                                                                                                                                                                                                                    sync: { (callback: Callback<any>): void; (): Promise<any> };

                                                                                                                                                                                                                                                                                                                                                                                                                                      method time

                                                                                                                                                                                                                                                                                                                                                                                                                                      time: {
                                                                                                                                                                                                                                                                                                                                                                                                                                      (callback: Callback<[string, string]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                      (): Promise<[string, string]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                        method ttl

                                                                                                                                                                                                                                                                                                                                                                                                                                        ttl: {
                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                          method type

                                                                                                                                                                                                                                                                                                                                                                                                                                          type: {
                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: KeyType, callback: Callback<string>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                            method unwatch

                                                                                                                                                                                                                                                                                                                                                                                                                                            unwatch: { (callback: Callback<string>): void; (): Promise<string> };

                                                                                                                                                                                                                                                                                                                                                                                                                                              method xlen

                                                                                                                                                                                                                                                                                                                                                                                                                                              xlen: {
                                                                                                                                                                                                                                                                                                                                                                                                                                              (key: KeyType): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                              (key: any, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                method zaddBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                zaddBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                score1: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                member1: Buffer,
                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: Callback<string | number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: any, score1: number, member1: Buffer): Promise<string | number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method zcard

                                                                                                                                                                                                                                                                                                                                                                                                                                                  zcard: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: KeyType, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: any): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method zcount

                                                                                                                                                                                                                                                                                                                                                                                                                                                    zcount: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    (key: any, min: string | number, max: string | number): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method zincrby

                                                                                                                                                                                                                                                                                                                                                                                                                                                      zincrby: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      increment: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      member: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<string>
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: any, increment: number, member: string): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method zpopmax

                                                                                                                                                                                                                                                                                                                                                                                                                                                        zpopmax: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: KeyType, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: any, count: number, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: any, count?: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method zpopmin

                                                                                                                                                                                                                                                                                                                                                                                                                                                          zpopmin: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: KeyType, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any, count: number, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any, count?: number): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method zrange

                                                                                                                                                                                                                                                                                                                                                                                                                                                            zrange: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            (key: any, start: number, stop: number, withScores?: 'WITHSCORES'): Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                            string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method zrangeBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                              zrangeBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              (key: any, start: number, stop: number, withScores?: 'WITHSCORES'): Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                              Buffer[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method zrangebylex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                zrangebylex: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, min: string, max: string): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: any, min: string, max: string, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method zrangebylexBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zrangebylexBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: KeyType, min: string, max: string): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: any, min: string, max: string, callback: Callback<Buffer[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method zrangebyscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zrangebyscore: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    withScores?: 'WITHSCORES'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method zrangebyscoreBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      zrangebyscoreBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withScores?: 'WITHSCORES'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method zrank

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        zrank: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: KeyType, member: string, callback: Callback<number | null>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: any, member: string): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method zremrangebylex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          zremrangebylex: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: KeyType, min: string, max: string): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: any, min: string, max: string, callback: Callback<number>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method zremrangebyrank

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            zremrangebyrank: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            callback: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (key: any, start: number, stop: number): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method zremrangebyscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              zremrangebyscore: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callback: Callback<number>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (key: any, min: string | number, max: string | number): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method zrevrange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                zrevrange: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: any, start: number, stop: number, withScores?: 'WITHSCORES'): Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                string[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method zrevrangeBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  zrevrangeBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stop: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: any, start: number, stop: number, withScores?: 'WITHSCORES'): Promise<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Buffer[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method zrevrangebylex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    zrevrangebylex: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (key: KeyType, max: string, min: string): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (key: any, max: string, min: string, callback: Callback<string[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method zrevrangebylexBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      zrevrangebylexBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: KeyType, min: string, max: string): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: any, min: string, max: string, callback: Callback<Buffer[]>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      min: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      max: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method zrevrangebyscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        zrevrangebyscore: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        withScores?: 'WITHSCORES'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): Promise<string[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        callback: Callback<string[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method zrevrangebyscoreBuffer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          zrevrangebyscoreBuffer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: number | string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          withScores?: 'WITHSCORES'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<Buffer[]>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          withScores: 'WITHSCORES',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          max: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          min: string | number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          limit: 'LIMIT',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          offset: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          count: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          callback: Callback<Buffer[]>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method zrevrank

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            zrevrank: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (key: KeyType, member: string, callback: Callback<number | null>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (key: any, member: string): Promise<number>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method zscanStream

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              zscanStream: (key: KeyType, options?: ScanStreamOption) => Readable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method zscore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                zscore: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, member: string, callback: Callback<string | null>): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: any, member: string): Promise<string>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MultiOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface MultiOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property pipeline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pipeline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NatMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NatMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        index signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NodeConfiguration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NodeConfiguration {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            host?: string | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              port?: number | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OverloadedBlockingListCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OverloadedBlockingListCommand<T, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  timeout: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    timeout: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (arg1: T, arg2: T, arg3: T, timeout: number): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (arg1: T, arg2: T, timeout: number): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (arg1: T, timeout: number): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (arg1: Array<T | number>): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (...args: Array<T | number>): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (arg1: T, arg2: T, arg3: T, arg4: T, timeout: number, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (arg1: T, arg2: T, arg3: T, timeout: number, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (arg1: T, arg2: T, timeout: number, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (arg1: T, timeout: number, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (arg1: Array<T | number>, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          timeout: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (arg1: T, arg2: T, arg3: T, arg4: T, arg5: T, timeout: number): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (arg1: T, arg2: T, arg3: T, arg4: T, timeout: number): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OverloadedCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface OverloadedCommand<T, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (...args: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (arg1: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OverloadedEvalCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OverloadedEvalCommand<T, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      script: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      numKeys: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        script: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        numKeys: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          script: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          numKeys: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            script: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            numKeys: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (script: string, numKeys: number, arg1: T, arg2: T, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (script: string, numKeys: number, arg1: T | T[], cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (script: string, numKeys: number, ...args: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (script: string, numKeys: number, arg1: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (args: ValueType[], callback?: Callback<any>): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OverloadedHashCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface OverloadedHashCommand<T, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (data: T[] | { [key: string]: T } | Map<string, T>, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (data: T[] | { [key: string]: T } | Map<string, T>): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (...args: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OverloadedKeyCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OverloadedKeyCommand<T, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg7: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        arg8: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          arg7: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, arg1: T, arg2: T, arg3: T, arg4: T, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: KeyType, arg1: T, arg2: T, arg3: T, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (key: KeyType, arg1: T, arg2: T, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (key: KeyType, arg1: T | T[], cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: KeyType, ...args: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (key: KeyType, arg1: T[]): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OverloadedKeyedHashCommand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface OverloadedKeyedHashCommand<T, U> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg1: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg2: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg3: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg4: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg5: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              arg6: T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (key: KeyType, arg1: T, arg2: T, arg3: T, arg4: T, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (key: KeyType, arg1: T, arg2: T, cb: Callback<U>): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data: T[] | { [key: string]: T } | Map<string, ValueType>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cb: Callback<U>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ): void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      key: KeyType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      data: T[] | { [key: string]: T } | Map<string, ValueType>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ): Promise<U>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (key: KeyType, ...args: T[]): Promise<U>;