@types/ioredis

  • Version 4.28.7
  • Published
  • 94.2 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 migrate

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

                                                                                                              property mset

                                                                                                              mset: 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 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>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface OverloadedListCommand

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