@redis/client - npm Package Compare versions

Comparing version 2.0.0-next.1 to 2.0.0-next.2

dist/index.d.ts

@@ -1,2 +0,2 @@
-export { RedisModules, RedisFunctions, RedisScripts, RespVersions } from './lib/RESP/types';
+export { RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, CommandPolicies } from './lib/RESP/types';
 export { RESP_TYPES } from './lib/RESP/decoder';
@@ -3,0 +3,0 @@ export { VerbatimString } from './lib/RESP/verbatim-string';

dist/index.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -11,5 +14,5 @@ exports.createCluster = exports.createClient = exports.defineScript = exports.VerbatimString = exports.RESP_TYPES = void 0;
 // export * from './lib/errors';
-const client_1 = require("./lib/client");
+const client_1 = __importDefault(require("./lib/client"));
 exports.createClient = client_1.default.create;
-const cluster_1 = require("./lib/cluster");
+const cluster_1 = __importDefault(require("./lib/cluster"));
 exports.createCluster = cluster_1.default.create;
@@ -16,0 +19,0 @@ // export { GeoReplyWith } from './lib/commands/generic-transformers';

dist/lib/client/commands-queue.d.ts

 /// <reference types="node" />
 /// <reference types="node" />
 import { Decoder } from '../RESP/decoder';
-import { CommandArguments, Flags, RespVersions } from '../RESP/types';
+import { CommandArguments, TypeMapping, RespVersions } from '../RESP/types';
 import { ChannelListeners, PubSubListener, PubSubType, PubSubTypeListeners } from './pub-sub';
 import { EventEmitter } from 'stream';
-export interface QueueCommandOptions {
+export interface CommandOptions<T = TypeMapping> {
+    chainId?: symbol;
     asap?: boolean;
-    chainId?: symbol;
-    signal?: AbortSignal;
-    flags?: Flags;
+    abortSignal?: AbortSignal;
+    /**
+     * Maps bettween RESP and JavaScript types
+     */
+    typeMapping?: T;
 }
@@ -16,3 +19,6 @@ export interface CommandWaitingToBeSent extends CommandWaitingForReply {
     chainId?: symbol;
-    removeAbortListener?(): void;
+    abort?: {
+        signal: AbortSignal;
+        listener: () => unknown;
+    };
 }
@@ -23,7 +29,6 @@ interface CommandWaitingForReply {
     channelsCounter?: number;
-    flags?: Flags;
+    typeMapping?: TypeMapping;
 }
 export type OnShardedChannelMoved = (channel: string, listeners: ChannelListeners) => void;
 export default class RedisCommandsQueue {
-    #private;
     private readonly _maxLength;
@@ -42,6 +47,6 @@ private readonly _waitingToBeSent;
     private _onPush;
-    private _getFlags;
+    private _getTypeMapping;
     private _initiateResp3Decoder;
     private _initiateResp2Decoder;
-    addCommand<T>(args: CommandArguments, options?: QueueCommandOptions): Promise<T>;
+    addCommand<T>(args: CommandArguments, options?: CommandOptions): Promise<T>;
     subscribe<T extends boolean>(type: PubSubType, channels: string | Array<string>, listener: PubSubListener<T>, returnBuffers?: T): Promise<void> | undefined;
@@ -54,6 +59,10 @@ unsubscribe<T extends boolean>(type: PubSubType, channels?: string | Array<string>, listener?: PubSubListener<T>, returnBuffers?: T): Promise<void> | undefined;
     private _pushPubSubCommand;
-    getCommandToSend(): CommandArguments | undefined;
+    waitingToBeSent(): Generator<CommandArguments, void, unknown>;
+    private _flushWaitingForReply;
+    private static _removeAbortListener;
+    private static _flushWaitingToBeSent;
     flushWaitingForReply(err: Error): void;
     flushAll(err: Error): void;
+    isEmpty(): boolean;
 }
 export {};

dist/lib/client/commands-queue.js

 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _RedisCommandsQueue_instances, _a, _RedisCommandsQueue_flushWaitingForReply, _RedisCommandsQueue_flushWaitingToBeSent;
 Object.defineProperty(exports, "__esModule", { value: true });
-const LinkedList = require("yallist");
-const encoder_1 = require("../RESP/encoder");
+const linked_list_1 = require("./linked-list");
+const encoder_1 = __importDefault(require("../RESP/encoder"));
 const decoder_1 = require("../RESP/decoder");
@@ -15,4 +12,4 @@ const pub_sub_1 = require("./pub-sub");
 const PONG = Buffer.from('pong');
-const RESP2_PUSH_FLAGS = {
-    ...decoder_1.PUSH_FLAGS,
+const RESP2_PUSH_TYPE_MAPPING = {
+    ...decoder_1.PUSH_TYPE_MAPPING,
     [decoder_1.RESP_TYPES.SIMPLE_STRING]: Buffer
@@ -25,45 +22,5 @@ };
     constructor(respVersion, maxLength, onShardedChannelMoved) {
-        _RedisCommandsQueue_instances.add(this);
-        Object.defineProperty(this, "_maxLength", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_waitingToBeSent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new LinkedList()
-        });
-        Object.defineProperty(this, "_waitingForReply", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new LinkedList()
-        });
-        Object.defineProperty(this, "_onShardedChannelMoved", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_pubSub", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new pub_sub_1.PubSub()
-        });
-        Object.defineProperty(this, "_chainInExecution", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "decoder", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+        this._waitingToBeSent = new linked_list_1.DoublyLinkedList();
+        this._waitingForReply = new linked_list_1.SinglyLinkedList();
+        this._pubSub = new pub_sub_1.PubSub();
         this.decoder = this._initiateDecoder(respVersion);
@@ -103,4 +60,4 @@ this._maxLength = maxLength;
     }
-    _getFlags() {
-        return this._waitingForReply.head.value.flags ?? {};
+    _getTypeMapping() {
+        return this._waitingForReply.head.value.typeMapping ?? {};
     }
@@ -115,3 +72,3 @@ _initiateResp3Decoder() {
             },
-            getFlags: () => this._getFlags()
+            getTypeMapping: () => this._getTypeMapping()
         });
@@ -126,4 +83,4 @@ }
                     if (PONG.equals(reply[0])) {
-                        const { resolve, flags } = this._waitingForReply.shift(), buffer = (reply[1].length === 0 ? reply[0] : reply[1]);
-                        resolve(flags?.[decoder_1.RESP_TYPES.SIMPLE_STRING] === Buffer ? buffer : buffer.toString());
+                        const { resolve, typeMapping } = this._waitingForReply.shift(), buffer = (reply[1].length === 0 ? reply[0] : reply[1]);
+                        resolve(typeMapping?.[decoder_1.RESP_TYPES.SIMPLE_STRING] === Buffer ? buffer : buffer.toString());
                         return;
@@ -139,7 +96,7 @@ }
             onPush: undefined,
-            getFlags: () => {
+            getTypeMapping: () => {
                 // PubSub push is an Array in RESP2
                 return this._pubSub.isActive ?
-                    RESP2_PUSH_FLAGS :
-                    this._getFlags();
+                    RESP2_PUSH_TYPE_MAPPING :
+                    this._getTypeMapping();
             }
@@ -152,27 +109,29 @@ });
         }
-        else if (options?.signal?.aborted) {
+        else if (options?.abortSignal?.aborted) {
             return Promise.reject(new errors_1.AbortError());
         }
         return new Promise((resolve, reject) => {
-            const node = new LinkedList.Node({
+            let node;
+            const value = {
                 args,
                 chainId: options?.chainId,
-                flags: options?.flags,
+                typeMapping: options?.typeMapping,
                 resolve,
-                reject
-            });
-            if (options?.signal) {
-                const listener = () => {
-                    this._waitingToBeSent.removeNode(node);
-                    node.value.reject(new errors_1.AbortError());
+                reject,
+                abort: undefined
+            };
+            const signal = options?.abortSignal;
+            if (signal) {
+                value.abort = {
+                    signal,
+                    listener: () => {
+                        this._waitingToBeSent.remove(node);
+                        value.reject(new errors_1.AbortError());
+                    }
                 };
-                node.value.removeAbortListener = () => options.signal?.removeEventListener('abort', listener);
-                options.signal.addEventListener('abort', listener, { once: true });
+                signal.addEventListener('abort', value.abort.listener, { once: true });
             }
-            if (options?.asap) {
-                this._waitingToBeSent.unshiftNode(node);
-            }
-            else {
-                this._waitingToBeSent.pushNode(node);
-            }
+            node = options?.asap ?
+                this._waitingToBeSent.unshift(value) :
+                this._waitingToBeSent.push(value);
         });
@@ -208,3 +167,3 @@ }
                 channelsCounter: command.channelsCounter,
-                flags: decoder_1.PUSH_FLAGS,
+                typeMapping: decoder_1.PUSH_TYPE_MAPPING,
                 resolve: () => {
@@ -221,24 +180,41 @@ command.resolve();
     }
-    getCommandToSend() {
-        const toSend = this._waitingToBeSent.shift();
-        if (!toSend)
-            return;
-        let encoded;
-        try {
-            encoded = (0, encoder_1.default)(toSend.args);
+    *waitingToBeSent() {
+        let toSend = this._waitingToBeSent.shift();
+        while (toSend) {
+            let encoded;
+            try {
+                encoded = (0, encoder_1.default)(toSend.args);
+            }
+            catch (err) {
+                toSend.reject(err);
+                toSend = this._waitingToBeSent.shift();
+                continue;
+            }
+            if (toSend.abort) {
+                RedisCommandsQueue._removeAbortListener(toSend);
+                toSend.abort = undefined;
+            }
+            // TODO reuse `toSend` or create new object?
+            toSend.args = undefined;
+            toSend.chainId = undefined;
+            this._waitingForReply.push(toSend);
+            this._chainInExecution = toSend.chainId;
+            yield encoded;
+            toSend = this._waitingToBeSent.shift();
         }
-        catch (err) {
-            toSend.reject(err);
-            return;
+    }
+    _flushWaitingForReply(err) {
+        for (const node of this._waitingForReply) {
+            node.reject(err);
         }
-        // TODO
-        // reuse `toSend`
-        toSend.args = undefined;
-        if (toSend.removeAbortListener) {
-            toSend.removeAbortListener();
-            toSend.removeAbortListener = undefined;
+        this._waitingForReply.reset();
+    }
+    static _removeAbortListener(command) {
+        command.abort.signal.removeEventListener('abort', command.abort.listener);
+    }
+    static _flushWaitingToBeSent(toBeSent, err) {
+        if (toBeSent.abort) {
+            RedisCommandsQueue._removeAbortListener(toBeSent);
         }
-        this._waitingForReply.push(toSend);
-        this._chainInExecution = toSend.chainId;
-        return encoded;
+        toBeSent.reject(err);
     }
@@ -248,7 +224,7 @@ flushWaitingForReply(err) {
         this._pubSub.reset();
-        __classPrivateFieldGet(this, _RedisCommandsQueue_instances, "m", _RedisCommandsQueue_flushWaitingForReply).call(this, err);
+        this._flushWaitingForReply(err);
         if (!this._chainInExecution)
             return;
         while (this._waitingToBeSent.head?.value.chainId === this._chainInExecution) {
-            __classPrivateFieldGet(RedisCommandsQueue, _a, "m", _RedisCommandsQueue_flushWaitingToBeSent).call(RedisCommandsQueue, this._waitingToBeSent.shift(), err);
+            RedisCommandsQueue._flushWaitingToBeSent(this._waitingToBeSent.shift(), err);
         }
@@ -260,16 +236,13 @@ this._chainInExecution = undefined;
         this._pubSub.reset();
-        __classPrivateFieldGet(this, _RedisCommandsQueue_instances, "m", _RedisCommandsQueue_flushWaitingForReply).call(this, err);
-        while (this._waitingToBeSent.head) {
-            __classPrivateFieldGet(RedisCommandsQueue, _a, "m", _RedisCommandsQueue_flushWaitingToBeSent).call(RedisCommandsQueue, this._waitingToBeSent.shift(), err);
+        this._flushWaitingForReply(err);
+        for (const node of this._waitingToBeSent) {
+            RedisCommandsQueue._flushWaitingToBeSent(node, err);
         }
+        this._waitingToBeSent.reset();
     }
+    isEmpty() {
+        return (this._waitingToBeSent.length === 0 &&
+            this._waitingForReply.length === 0);
+    }
 }
 exports.default = RedisCommandsQueue;
-_a = RedisCommandsQueue, _RedisCommandsQueue_instances = new WeakSet(), _RedisCommandsQueue_flushWaitingForReply = function _RedisCommandsQueue_flushWaitingForReply(err) {
-    while (this._waitingForReply.head) {
-        this._waitingForReply.shift().reject(err);
-    }
-}, _RedisCommandsQueue_flushWaitingToBeSent = function _RedisCommandsQueue_flushWaitingToBeSent(command, err) {
-    command.removeAbortListener?.();
-    command.reject(err);
-};

dist/lib/client/index.d.ts

 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import COMMANDS from '../commands';
 import { RedisSocketOptions } from './socket';
-import { QueueCommandOptions } from './commands-queue';
+import { CommandOptions } from './commands-queue';
 import { EventEmitter } from 'events';
 import { PubSubType, PubSubListener, PubSubTypeListeners, ChannelListeners } from './pub-sub';
-import { CommandArguments, CommandSignature, Flags, CommanderConfig, RedisFunctions, RedisModules, RedisScripts, ReplyUnion, RespVersions, RedisArgument } from '../RESP/types';
+import { CommandArguments, CommandSignature, TypeMapping, CommanderConfig, RedisFunctions, RedisModules, RedisScripts, ReplyUnion, RespVersions, RedisArgument } from '../RESP/types';
 import { RedisClientMultiCommandType } from './multi-command';
-import { Options as PoolOptions } from 'generic-pool';
-import { ReplyWithFlags, CommandReply } from '../RESP/types';
-import SCAN, { ScanOptions, ScanCommonOptions } from '../commands/SCAN';
-export interface RedisClientOptions<M extends RedisModules = RedisModules, F extends RedisFunctions = RedisFunctions, S extends RedisScripts = RedisScripts, RESP extends RespVersions = RespVersions> extends CommanderConfig<M, F, S, RESP> {
+import { RedisMultiQueuedCommand } from '../multi-command';
+import { ScanOptions, ScanCommonOptions } from '../commands/SCAN';
+import { RedisLegacyClientType } from './legacy-mode';
+interface ClientCommander<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> extends CommanderConfig<M, F, S, RESP> {
+    commandOptions?: CommandOptions<TYPE_MAPPING>;
+}
+export interface RedisClientOptions<M extends RedisModules = RedisModules, F extends RedisFunctions = RedisFunctions, S extends RedisScripts = RedisScripts, RESP extends RespVersions = RespVersions, TYPE_MAPPING extends TypeMapping = TypeMapping> extends ClientCommander<M, F, S, RESP, TYPE_MAPPING> {
     /**
@@ -53,10 +57,2 @@ * `redis[s]://[[username][:password]@][host][:port][/db-number]`
     /**
-     * TODO
-     */
-    legacyMode?: boolean;
-    /**
-     * TODO
-     */
-    isolationPoolOptions?: PoolOptions;
-    /**
      * Send `PING` command at interval (in ms).
@@ -67,26 +63,24 @@ * Useful with Redis deployments that do not use TCP Keep-Alive.
 }
-type WithCommands<RESP extends RespVersions, FLAGS extends Flags> = {
-    [P in keyof typeof COMMANDS]: CommandSignature<(typeof COMMANDS)[P], RESP, FLAGS>;
+type WithCommands<RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
+    [P in keyof typeof COMMANDS]: CommandSignature<(typeof COMMANDS)[P], RESP, TYPE_MAPPING>;
 };
-type WithModules<M extends RedisModules, RESP extends RespVersions, FLAGS extends Flags> = {
+type WithModules<M extends RedisModules, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
     [P in keyof M]: {
-        [C in keyof M[P]]: CommandSignature<M[P][C], RESP, FLAGS>;
+        [C in keyof M[P]]: CommandSignature<M[P][C], RESP, TYPE_MAPPING>;
     };
 };
-type WithFunctions<F extends RedisFunctions, RESP extends RespVersions, FLAGS extends Flags> = {
+type WithFunctions<F extends RedisFunctions, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
     [L in keyof F]: {
-        [C in keyof F[L]]: CommandSignature<F[L][C], RESP, FLAGS>;
+        [C in keyof F[L]]: CommandSignature<F[L][C], RESP, TYPE_MAPPING>;
     };
 };
-type WithScripts<S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = {
-    [P in keyof S]: CommandSignature<S[P], RESP, FLAGS>;
+type WithScripts<S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
+    [P in keyof S]: CommandSignature<S[P], RESP, TYPE_MAPPING>;
 };
-export type RedisClientType<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, FLAGS extends Flags = {}> = (RedisClient<M, F, S, RESP, FLAGS> & WithCommands<RESP, FLAGS> & WithModules<M, RESP, FLAGS> & WithFunctions<F, RESP, FLAGS> & WithScripts<S, RESP, FLAGS>);
-export interface ClientCommandOptions extends QueueCommandOptions {
-    isolated?: boolean;
-}
+export type RedisClientExtensions<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}> = (WithCommands<RESP, TYPE_MAPPING> & WithModules<M, RESP, TYPE_MAPPING> & WithFunctions<F, RESP, TYPE_MAPPING> & WithScripts<S, RESP, TYPE_MAPPING>);
+export type RedisClientType<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}> = (RedisClient<M, F, S, RESP, TYPE_MAPPING> & RedisClientExtensions<M, F, S, RESP, TYPE_MAPPING>);
 interface ScanIteratorOptions {
     cursor?: number;
 }
-export default class RedisClient<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> extends EventEmitter {
+export default class RedisClient<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> extends EventEmitter {
     private static _createCommand;
@@ -96,4 +90,4 @@ private static _createModuleCommand;
     private static _createScriptCommand;
-    static factory<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2>(config?: CommanderConfig<M, F, S, RESP>): (options?: Omit<RedisClientOptions, keyof Exclude<typeof config, undefined>>) => RedisClientType<M, F, S, RESP, {}>;
-    static create<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2>(options?: RedisClientOptions<M, F, S, RESP>): RedisClientType<M, F, S, RESP, {}>;
+    static factory<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}>(config?: ClientCommander<M, F, S, RESP, TYPE_MAPPING>): (options?: Omit<RedisClientOptions, keyof Exclude<typeof config, undefined>>) => RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
+    static create<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}>(this: void, options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>): RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
     static parseURL(url: string): RedisClientOptions;
@@ -104,4 +98,4 @@ self: this;
     private readonly _queue;
-    private _isolationPool?;
     private _selectedDB;
+    private _commandOptions?;
     get options(): RedisClientOptions<M, F, S, RESP> | undefined;
@@ -111,3 +105,3 @@ get isOpen(): boolean;
     get isPubSubActive(): boolean;
-    constructor(options?: RedisClientOptions<M, F, S, RESP>);
+    constructor(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>);
     private _initiateOptions;
@@ -118,20 +112,26 @@ private _initiateQueue;
     private _setPingTimer;
-    withCommandOptions<T extends ClientCommandOptions>(options: T): RedisClientType<M, F, S, RESP, T["flags"] extends Flags ? T["flags"] : {}>;
+    withCommandOptions<OPTIONS extends CommandOptions<TYPE_MAPPING>, TYPE_MAPPING extends TypeMapping>(options: OPTIONS): RedisClientType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping ? TYPE_MAPPING : {}>;
     private _commandOptionsProxy;
     /**
-     * Override the `flags` command option
+     * Override the `typeMapping` command option
      */
-    withFlags<FLAGS extends Flags>(flags: FLAGS): RedisClientType<M, F, S, RESP, FLAGS extends Flags ? FLAGS : {}>;
+    withTypeMapping<TYPE_MAPPING extends TypeMapping>(typeMapping: TYPE_MAPPING): RedisClientType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping ? TYPE_MAPPING : {}>;
     /**
+     * Override the `abortSignal` command option
+     */
+    withAbortSignal(abortSignal: AbortSignal): RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
+    /**
      * Override the `asap` command option to `true`
      */
-    asap(): RedisClientType<M, F, S, RESP, FLAGS>;
+    asap(): RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
     /**
-     * Override the `isolated` command option to `true`
+     * Create the "legacy" (v3/callback) interface
      */
-    isolated(): RedisClientType<M, F, S, RESP, FLAGS>;
-    duplicate(overrides?: Partial<RedisClientOptions<M, F, S, RESP>>): RedisClientType<M, F, S, RESP, {}>;
+    legacy(): RedisLegacyClientType;
+    /**
+     * Create `RedisClientPool` using this client as a prototype
+     */
+    duplicate<_M extends RedisModules = M, _F extends RedisFunctions = F, _S extends RedisScripts = S, _RESP extends RespVersions = RESP, _TYPE_MAPPING extends TypeMapping = TYPE_MAPPING>(overrides?: Partial<RedisClientOptions<_M, _F, _S, _RESP, _TYPE_MAPPING>>): RedisClientType<_M, _F, _S, _RESP, _TYPE_MAPPING>;
     connect(): Promise<void>;
-    sendCommand: <T = ReplyUnion>(args: CommandArguments, options?: ClientCommandOptions) => Promise<T>;
-    _sendCommand<T = ReplyUnion>(args: CommandArguments, options?: ClientCommandOptions): Promise<T>;
+    sendCommand<T = ReplyUnion>(args: CommandArguments, options?: CommandOptions): Promise<T>;
     SELECT(db: number): Promise<void>;
@@ -155,21 +155,42 @@ select: (db: number) => Promise<void>;
     extendPubSubListeners(type: PubSubType, listeners: PubSubTypeListeners): Promise<void>;
-    QUIT(): Promise<string>;
-    quit: () => Promise<string>;
-    _tick(force?: boolean): void;
-    executeIsolated<T>(fn: (client: RedisClientType<M, F, S, RESP, FLAGS>) => T | Promise<T>): Promise<T>;
-    private _addMultiCommands;
-    MULTI(): RedisClientMultiCommandType<[], M, F, S, RESP, FLAGS>;
-    multi: () => RedisClientMultiCommandType<[], M, F, S, RESP, FLAGS>;
-    scanIterator(this: RedisClientType<M, F, S, RESP, FLAGS>, options?: ScanOptions & ScanIteratorOptions): AsyncIterable<ReplyWithFlags<CommandReply<typeof SCAN, RESP>['keys'], FLAGS>>;
-    hScanIterator(this: RedisClientType<M, F, S, RESP, FLAGS>, key: RedisArgument, options?: ScanCommonOptions & ScanIteratorOptions): AsyncGenerator<{
-        field: (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string) | (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string);
-        value: (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string) | (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string);
+    private _write;
+    private _scheduledWrite?;
+    private _scheduleWrite;
+    /**
+     * @internal
+     */
+    executePipeline(commands: Array<RedisMultiQueuedCommand>): Promise<unknown[]>;
+    /**
+     * @internal
+     */
+    executeMulti(commands: Array<RedisMultiQueuedCommand>, selectedDB?: number): Promise<unknown[]>;
+    MULTI(): RedisClientMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>;
+    multi: () => RedisClientMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>;
+    scanIterator(this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, options?: ScanOptions & ScanIteratorOptions): AsyncGenerator<TYPE_MAPPING[42] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<import("../RESP/types").BlobStringReply[], T>, TYPE_MAPPING> : ((TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string) | (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string))[], void, unknown>;
+    hScanIterator(this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, key: RedisArgument, options?: ScanCommonOptions & ScanIteratorOptions): AsyncGenerator<{
+        field: (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string) | (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string);
+        value: (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string) | (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string);
     }[], void, unknown>;
-    sScanIterator(this: RedisClientType<M, F, S, RESP, FLAGS>, key: RedisArgument, options?: ScanCommonOptions & ScanIteratorOptions): AsyncGenerator<((FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string) | (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string))[], void, unknown>;
-    zScanIterator(this: RedisClientType<M, F, S, RESP, FLAGS>, key: RedisArgument, options?: ScanCommonOptions & ScanIteratorOptions): AsyncGenerator<{
-        value: (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string) | (FLAGS[36] extends import("../RESP/types").Flag<infer T> ? ReplyWithFlags<Extract<string, T>, FLAGS> | ReplyWithFlags<Extract<Buffer, T>, FLAGS> : string);
+    sScanIterator(this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, key: RedisArgument, options?: ScanCommonOptions & ScanIteratorOptions): AsyncGenerator<((TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string) | (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string))[], void, unknown>;
+    zScanIterator(this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, key: RedisArgument, options?: ScanCommonOptions & ScanIteratorOptions): AsyncGenerator<{
+        value: (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string) | (TYPE_MAPPING[36] extends import("../RESP/types").Flag<infer T> ? import("../RESP/types").ReplyWithTypeMapping<Extract<string, T>, TYPE_MAPPING> | import("../RESP/types").ReplyWithTypeMapping<Extract<Buffer, T>, TYPE_MAPPING> : string);
         score: number;
     }[], void, unknown>;
+    /**
+     * @deprecated use .close instead
+     */
+    QUIT(): Promise<string>;
+    quit: () => Promise<string>;
+    /**
+     * @deprecated use .destroy instead
+     */
     disconnect(): Promise<void>;
-    private _destroyIsolationPool;
+    /**
+     * Close the client. Wait for pending commands.
+     */
+    close(): Promise<void>;
+    /**
+     * Destroy the client. Rejects all commands immediately.
+     */
+    destroy(): void;
     ref(): void;
@@ -176,0 +197,0 @@ unref(): void;

dist/lib/client/index.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const commands_1 = require("../commands");
-const socket_1 = require("./socket");
-const commands_queue_1 = require("./commands-queue");
+const commands_1 = __importDefault(require("../commands"));
+const socket_1 = __importDefault(require("./socket"));
+const commands_queue_1 = __importDefault(require("./commands-queue"));
 const events_1 = require("events");
@@ -11,12 +14,12 @@ const commander_1 = require("../commander");
 const pub_sub_1 = require("./pub-sub");
-const multi_command_1 = require("./multi-command");
-const HELLO_1 = require("../commands/HELLO");
-const generic_pool_1 = require("generic-pool");
+const multi_command_1 = __importDefault(require("./multi-command"));
+const HELLO_1 = __importDefault(require("../commands/HELLO"));
+const legacy_mode_1 = require("./legacy-mode");
 class RedisClient extends events_1.EventEmitter {
     static _createCommand(command, resp) {
         const transformReply = (0, commander_1.getTransformReply)(command, resp);
-        return async function () {
-            const args = command.transformArguments.apply(undefined, arguments), reply = await this._sendCommand(args, this.commandOptions);
+        return async function (...args) {
+            const redisArgs = command.transformArguments(...args), reply = await this.sendCommand(redisArgs, this._commandOptions);
             return transformReply ?
-                transformReply(reply, args.preserve) :
+                transformReply(reply, redisArgs.preserve) :
                 reply;
@@ -27,6 +30,6 @@ };
         const transformReply = (0, commander_1.getTransformReply)(command, resp);
-        return async function () {
-            const args = command.transformArguments.apply(undefined, arguments), reply = await this.self._sendCommand(args, this.self.commandOptions);
+        return async function (...args) {
+            const redisArgs = command.transformArguments(...args), reply = await this.self.sendCommand(redisArgs, this.self._commandOptions);
             return transformReply ?
-                transformReply(reply, args.preserve) :
+                transformReply(reply, redisArgs.preserve) :
                 reply;
@@ -37,4 +40,4 @@ };
         const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn), transformReply = (0, commander_1.getTransformReply)(fn, resp);
-        return async function () {
-            const fnArgs = fn.transformArguments.apply(undefined, arguments), reply = await this.self._sendCommand(prefix.concat(fnArgs), this.self.commandOptions);
+        return async function (...args) {
+            const fnArgs = fn.transformArguments(...args), reply = await this.self.sendCommand(prefix.concat(fnArgs), this.self._commandOptions);
             return transformReply ?
@@ -47,9 +50,9 @@ transformReply(reply, fnArgs.preserve) :
         const prefix = (0, commander_1.scriptArgumentsPrefix)(script), transformReply = (0, commander_1.getTransformReply)(script, resp);
-        return async function () {
-            const scriptArgs = script.transformArguments.apply(undefined, arguments), args = prefix.concat(scriptArgs), reply = await this._sendCommand(args, this.commandOptions).catch((err) => {
+        return async function (...args) {
+            const scriptArgs = script.transformArguments(...args), redisArgs = prefix.concat(scriptArgs), reply = await this.sendCommand(redisArgs, this._commandOptions).catch((err) => {
                 if (!err?.message?.startsWith?.('NOSCRIPT'))
                     throw err;
-                args[0] = 'EVAL';
-                args[1] = script.SCRIPT;
-                return this._sendCommand(args, this.commandOptions);
+                redisArgs[0] = 'EVAL';
+                redisArgs[1] = script.SCRIPT;
+                return this.sendCommand(redisArgs, this._commandOptions);
             });
@@ -124,170 +127,18 @@ return transformReply ?
     }
-    // get v4(): Record<string, any> {
-    //   if (!this.client.#options?.legacyMode) {
-    //     throw new Error('the client is not in "legacy mode"');
-    //   }
-    //   return this.client.#v4;
-    // }
     constructor(options) {
         super();
-        Object.defineProperty(this, "self", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this
-        });
-        Object.defineProperty(this, "_options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_socket", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_isolationPool", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // readonly #v4: Record<string, any> = {};
-        Object.defineProperty(this, "_selectedDB", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        // #legacyMode(): void {
-        //   if (!this.#options?.legacyMode) return;
-        //   (this as any).#v4.sendCommand = this.#sendCommand.bind(this);
-        //   (this as any).sendCommand = (...args: Array<any>): void => {
-        //     const result = this.#legacySendCommand(...args);
-        //     if (result) {
-        //       result.promise
-        //         .then(reply => result.callback(null, reply))
-        //         .catch(err => result.callback(err));
-        //     }
-        //   };
-        //   for (const [name, command] of Object.entries(COMMANDS)) {
-        //     this.#defineLegacyCommand(name, command);
-        //     (this as any)[name.toLowerCase()] ??= (this as any)[name];
-        //   }
-        //   // hard coded commands
-        //   this.#defineLegacyCommand('SELECT');
-        //   this.#defineLegacyCommand('select');
-        //   this.#defineLegacyCommand('SUBSCRIBE');
-        //   this.#defineLegacyCommand('subscribe');
-        //   this.#defineLegacyCommand('PSUBSCRIBE');
-        //   this.#defineLegacyCommand('pSubscribe');
-        //   this.#defineLegacyCommand('UNSUBSCRIBE');
-        //   this.#defineLegacyCommand('unsubscribe');
-        //   this.#defineLegacyCommand('PUNSUBSCRIBE');
-        //   this.#defineLegacyCommand('pUnsubscribe');
-        //   this.#defineLegacyCommand('QUIT');
-        //   this.#defineLegacyCommand('quit');
-        // }
-        // #legacySendCommand(...args: Array<any>) {
-        //   const callback = typeof args[args.length - 1] === 'function' ?
-        //     args.pop() as ClientLegacyCallback :
-        //     undefined;
-        //   const promise = this.#sendCommand(transformLegacyCommandArguments(args));
-        //   if (callback) return {
-        //     promise,
-        //     callback
-        //   };
-        //   promise.catch(err => this.emit('error', err));
-        // }
-        // #defineLegacyCommand(name: string, command?: RedisCommand): void {
-        //   this.#v4[name] = (this as any)[name].bind(this);
-        //   (this as any)[name] = command && command.TRANSFORM_LEGACY_REPLY && command.transformReply ?
-        //     (...args: Array<unknown>) => {
-        //       const result = this.#legacySendCommand(name, ...args);
-        //       if (result) {
-        //         result.promise
-        //           .then(reply => result.callback(null, command.transformReply!(reply)))
-        //           .catch(err => result.callback(err));
-        //       }
-        //     } :
-        //     (...args: Array<unknown>) => (this as any).sendCommand(name, ...args);
-        // }
-        Object.defineProperty(this, "_pingTimer", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "sendCommand", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this._sendCommand.bind(this)
-        });
-        Object.defineProperty(this, "select", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SELECT
-        });
-        Object.defineProperty(this, "subscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SUBSCRIBE
-        });
-        Object.defineProperty(this, "unsubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.UNSUBSCRIBE
-        });
-        Object.defineProperty(this, "pSubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.PSUBSCRIBE
-        });
-        Object.defineProperty(this, "pUnsubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.PUNSUBSCRIBE
-        });
-        Object.defineProperty(this, "sSubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SSUBSCRIBE
-        });
-        Object.defineProperty(this, "sUnsubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SUNSUBSCRIBE
-        });
-        Object.defineProperty(this, "quit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.QUIT
-        });
-        Object.defineProperty(this, "multi", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.MULTI
-        });
+        this.self = this;
+        this._selectedDB = 0;
+        this.select = this.SELECT;
+        this.subscribe = this.SUBSCRIBE;
+        this.unsubscribe = this.UNSUBSCRIBE;
+        this.pSubscribe = this.PSUBSCRIBE;
+        this.pUnsubscribe = this.PUNSUBSCRIBE;
+        this.sSubscribe = this.SSUBSCRIBE;
+        this.sUnsubscribe = this.SUNSUBSCRIBE;
+        this.multi = this.MULTI;
+        this.quit = this.QUIT;
         this._options = this._initiateOptions(options);
         this._queue = this._initiateQueue();
         this._socket = this._initiateSocket();
-        // this.#legacyMode();
     }
@@ -305,2 +156,5 @@ _initiateOptions(options) {
         }
+        if (options?.commandOptions) {
+            this._commandOptions = options.commandOptions;
+        }
         return options;
@@ -318,8 +172,3 @@ }
             if (this._options?.readonly) {
-                // promises.push(
-                //     this.#queue.addCommand(
-                //         COMMANDS.READONLY.transformArguments(),
-                //         { asap: true }
-                //     )
-                // );
+                promises.push(this._queue.addCommand(commands_1.default.READONLY.transformArguments(), { asap: true }));
             }
@@ -341,19 +190,9 @@ if (this._options?.RESP) {
                 if (this._options?.name) {
-                    // promises.push(
-                    //     this.#queue.addCommand(
-                    //         COMMANDS.CLIENT_SETNAME.transformArguments(this.#options.name),
-                    //         { asap: true }
-                    //     )
-                    // );
+                    promises.push(this._queue.addCommand(commands_1.default.CLIENT_SETNAME.transformArguments(this._options.name), { asap: true }));
                 }
                 if (this._options?.username || this._options?.password) {
-                    // promises.push(
-                    //     this.#queue.addCommand(
-                    //         COMMANDS.AUTH.transformArguments({
-                    //             username: this.#options.username,
-                    //             password: this.#options.password ?? ''
-                    //         }),
-                    //         { asap: true }
-                    //     )
-                    // );
+                    promises.push(this._queue.addCommand(commands_1.default.AUTH.transformArguments({
+                        username: this._options.username,
+                        password: this._options.password ?? ''
+                    }), { asap: true }));
                 }
@@ -366,3 +205,3 @@ }
             if (promises.length) {
-                this._tick(true);
+                this._write();
                 await Promise.all(promises);
@@ -372,3 +211,11 @@ }
         return new socket_1.default(socketInitiator, this._options?.socket)
-            .on('data', chunk => this._queue.decoder.write(chunk))
+            .on('data', chunk => {
+            try {
+                this._queue.decoder.write(chunk);
+            }
+            catch (err) {
+                this._queue.decoder.reset();
+                this.emit('error', err);
+            }
+        })
             .on('error', err => {
@@ -387,6 +234,6 @@ this.emit('error', err);
             this._setPingTimer();
-            this._tick();
+            this._scheduleWrite();
         })
             .on('reconnecting', () => this.emit('reconnecting'))
-            .on('drain', () => this._tick())
+            .on('drain', () => this._scheduleWrite())
             .on('end', () => this.emit('end'));
@@ -401,4 +248,3 @@ }
                 return;
-            // using _sendCommand to support legacy mode
-            this._sendCommand(['PING'])
+            this.sendCommand(['PING'])
                 .then(reply => this.emit('ping-interval', reply))
@@ -411,3 +257,3 @@ .catch(err => this.emit('error', err))
         const proxy = Object.create(this.self);
-        proxy.commandOptions = options;
+        proxy._commandOptions = options;
         return proxy;
@@ -417,13 +263,19 @@ }
         const proxy = Object.create(this.self);
-        proxy.commandOptions = Object.create(this.commandOptions ?? null);
-        proxy.commandOptions[key] = value;
+        proxy._commandOptions = Object.create(this._commandOptions ?? null);
+        proxy._commandOptions[key] = value;
         return proxy;
     }
     /**
-     * Override the `flags` command option
+     * Override the `typeMapping` command option
      */
-    withFlags(flags) {
-        return this._commandOptionsProxy('flags', flags);
+    withTypeMapping(typeMapping) {
+        return this._commandOptionsProxy('typeMapping', typeMapping);
     }
     /**
+     * Override the `abortSignal` command option
+     */
+    withAbortSignal(abortSignal) {
+        return this._commandOptionsProxy('abortSignal', abortSignal);
+    }
+    /**
      * Override the `asap` command option to `true`
@@ -435,37 +287,29 @@ */
     /**
-     * Override the `isolated` command option to `true`
+     * Create the "legacy" (v3/callback) interface
      */
-    isolated() {
-        return this._commandOptionsProxy('isolated', true);
+    legacy() {
+        return new legacy_mode_1.RedisLegacyClient(this);
     }
+    /**
+     * Create `RedisClientPool` using this client as a prototype
+     */
+    // pool() {
+    //   return RedisClientPool.fromClient(
+    //     this as unknown as RedisClientType<M, F, S, RESP>
+    //   );
+    // }
     duplicate(overrides) {
         return new (Object.getPrototypeOf(this).constructor)({
             ...this._options,
+            commandOptions: this._commandOptions,
             ...overrides
         });
     }
-    async connect() {
-        await this._socket.connect();
-        this.self._isolationPool = (0, generic_pool_1.createPool)({
-            create: async () => {
-                const duplicate = this.duplicate({
-                    isolationPoolOptions: undefined
-                }).on('error', err => this.emit('error', err));
-                await duplicate.connect();
-                return duplicate;
-            },
-            destroy: client => client.disconnect()
-        }, this._options?.isolationPoolOptions);
+    connect() {
+        return this._socket.connect();
     }
-    // using `_` to avoid conflicts with the legacy mode
-    _sendCommand(args, options) {
+    sendCommand(args, options) {
         if (!this._socket.isOpen) {
             return Promise.reject(new errors_1.ClientClosedError());
         }
-        else if (options?.isolated) {
-            return this.executeIsolated(isolatedClient => isolatedClient.sendCommand(args, {
-                ...options,
-                isolated: false
-            }));
-        }
         else if (!this._socket.isReady && this._options?.disableOfflineQueue) {
@@ -475,7 +319,7 @@ return Promise.reject(new errors_1.ClientOfflineError());
         const promise = this._queue.addCommand(args, options);
-        this._tick();
+        this._scheduleWrite();
         return promise;
     }
     async SELECT(db) {
-        await this._sendCommand(['SELECT', db.toString()]);
+        await this.sendCommand(['SELECT', db.toString()]);
         this._selectedDB = db;
@@ -486,7 +330,6 @@ }
             return Promise.resolve();
-        this._tick();
+        this._scheduleWrite();
         return promise;
     }
     SUBSCRIBE(channels, listener, bufferMode) {
-        console.log('SUBSCRIBE', channels, listener, bufferMode, this._options?.RESP);
         return this._pubSubCommand(this._queue.subscribe(pub_sub_1.PubSubType.CHANNELS, channels, listener, bufferMode));
@@ -518,59 +361,56 @@ }
     }
-    QUIT() {
-        return this._socket.quit(async () => {
-            const quitPromise = this._queue.addCommand(['QUIT']);
-            this._tick();
-            const [reply] = await Promise.all([
-                quitPromise,
-                this._destroyIsolationPool()
-            ]);
-            return reply;
+    _write() {
+        this._socket.write(this._queue.waitingToBeSent());
+    }
+    _scheduleWrite() {
+        if (!this.isReady || this._scheduledWrite)
+            return;
+        this._scheduledWrite = setImmediate(() => {
+            this._write();
+            this._scheduledWrite = undefined;
         });
     }
-    _tick(force = false) {
-        if (this._socket.writableNeedDrain || (!force && !this._socket.isReady)) {
-            return;
+    /**
+     * @internal
+     */
+    executePipeline(commands) {
+        if (!this._socket.isOpen) {
+            return Promise.reject(new errors_1.ClientClosedError());
         }
-        this._socket.cork();
-        while (!this._socket.writableNeedDrain) {
-            const args = this._queue.getCommandToSend();
-            if (args === undefined)
-                break;
-            this._socket.writeCommand(args);
-        }
-    }
-    executeIsolated(fn) {
-        return this._isolationPool ?
-            this._isolationPool.use(fn) :
-            Promise.reject(new errors_1.ClientClosedError());
-    }
-    _addMultiCommands(commands, chainId, flags) {
-        return Promise.all(commands.map(({ args }) => this._queue.addCommand(args, {
-            chainId,
-            flags
+        const promise = Promise.all(commands.map(({ args }) => this._queue.addCommand(args, {
+            typeMapping: this._commandOptions?.typeMapping
         })));
+        this._scheduleWrite();
+        return promise;
     }
-    MULTI() {
-        return new this.Multi(async (commands, selectedDB, chainId) => {
-            if (!this._socket.isOpen) {
-                return Promise.reject(new errors_1.ClientClosedError());
-            }
-            const flags = this.commandOptions?.flags, promise = chainId ?
-                // if `chainId` has a value, it's a `MULTI` (and not "pipeline") - need to add the `MULTI` and `EXEC` commands
-                Promise.all([
-                    this._queue.addCommand(['MULTI'], { chainId }),
-                    this._addMultiCommands(commands, chainId),
-                    this._queue.addCommand(['EXEC'], { chainId, flags })
-                ]) :
-                this._addMultiCommands(commands, undefined, flags);
-            this._tick();
-            const results = await promise;
-            if (selectedDB !== undefined) {
-                this._selectedDB = selectedDB;
-            }
-            return results;
+    /**
+     * @internal
+     */
+    async executeMulti(commands, selectedDB) {
+        if (!this._socket.isOpen) {
+            return Promise.reject(new errors_1.ClientClosedError());
         }
-        // self.#options?.legacyMode
-        );
+        const typeMapping = this._commandOptions?.typeMapping, chainId = Symbol('MULTI Chain'), promises = [
+            this._queue.addCommand(['MULTI'], { chainId }),
+        ];
+        for (const { args } of commands) {
+            promises.push(this._queue.addCommand(args, {
+                chainId,
+                typeMapping
+            }));
+        }
+        promises.push(this._queue.addCommand(['EXEC'], { chainId }));
+        this._scheduleWrite();
+        const results = await Promise.all(promises), execResult = results[results.length - 1];
+        if (execResult === null) {
+            throw new errors_1.WatchError();
+        }
+        if (selectedDB !== undefined) {
+            this._selectedDB = selectedDB;
+        }
+        return execResult;
     }
+    MULTI() {
+        return new this.Multi(this);
+    }
     async *scanIterator(options) {
@@ -608,12 +448,48 @@ let cursor = options?.cursor ?? 0;
     }
-    async disconnect() {
+    /**
+     * @deprecated use .close instead
+     */
+    QUIT() {
+        return this._socket.quit(async () => {
+            clearTimeout(this._pingTimer);
+            const quitPromise = this._queue.addCommand(['QUIT']);
+            this._scheduleWrite();
+            return quitPromise;
+        });
+    }
+    /**
+     * @deprecated use .destroy instead
+     */
+    disconnect() {
+        return Promise.resolve(this.destroy());
+    }
+    /**
+     * Close the client. Wait for pending commands.
+     */
+    close() {
+        return new Promise(resolve => {
+            clearTimeout(this._pingTimer);
+            this._socket.close();
+            if (this._queue.isEmpty()) {
+                this._socket.destroySocket();
+                return resolve();
+            }
+            const maybeClose = () => {
+                if (!this._queue.isEmpty())
+                    return;
+                this._socket.off('data', maybeClose);
+                this._socket.destroySocket();
+                resolve();
+            };
+            this._socket.on('data', maybeClose);
+        });
+    }
+    /**
+     * Destroy the client. Rejects all commands immediately.
+     */
+    destroy() {
+        clearTimeout(this._pingTimer);
         this._queue.flushAll(new errors_1.DisconnectsClientError());
-        this._socket.disconnect();
-        await this._destroyIsolationPool();
+        this._socket.destroy();
     }
-    async _destroyIsolationPool() {
-        await this._isolationPool.drain();
-        await this._isolationPool.clear();
-        this.self._isolationPool = undefined;
-    }
     ref() {
@@ -620,0 +496,0 @@ this._socket.ref();

dist/lib/client/multi-command.d.ts

 import COMMANDS from '../commands';
-import RedisMultiCommand, { RedisMultiQueuedCommand } from '../multi-command';
-import { ReplyWithFlags, CommandReply, Command, CommanderConfig, RedisFunctions, RedisModules, RedisScripts, RespVersions, TransformReply, Flags, ReplyUnion } from '../RESP/types';
-type CommandSignature<REPLIES extends Array<unknown>, C extends Command, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = (...args: Parameters<C['transformArguments']>) => RedisClientMultiCommandType<[
+import { MULTI_REPLY, MultiReply, MultiReplyType } from '../multi-command';
+import { ReplyWithTypeMapping, CommandReply, Command, CommandArguments, CommanderConfig, RedisFunctions, RedisModules, RedisScripts, RespVersions, TransformReply, TypeMapping } from '../RESP/types';
+import { RedisClientType } from '.';
+type CommandSignature<REPLIES extends Array<unknown>, C extends Command, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = (...args: Parameters<C['transformArguments']>) => RedisClientMultiCommandType<[
     ...REPLIES,
-    ReplyWithFlags<CommandReply<C, RESP>, FLAGS>
-], M, F, S, RESP, FLAGS>;
-type WithCommands<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = {
-    [P in keyof typeof COMMANDS]: CommandSignature<REPLIES, (typeof COMMANDS)[P], M, F, S, RESP, FLAGS>;
+    ReplyWithTypeMapping<CommandReply<C, RESP>, TYPE_MAPPING>
+], M, F, S, RESP, TYPE_MAPPING>;
+type WithCommands<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
+    [P in keyof typeof COMMANDS]: CommandSignature<REPLIES, (typeof COMMANDS)[P], M, F, S, RESP, TYPE_MAPPING>;
 };
-type WithModules<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = {
+type WithModules<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
     [P in keyof M]: {
-        [C in keyof M[P]]: CommandSignature<REPLIES, M[P][C], M, F, S, RESP, FLAGS>;
+        [C in keyof M[P]]: CommandSignature<REPLIES, M[P][C], M, F, S, RESP, TYPE_MAPPING>;
     };
 };
-type WithFunctions<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = {
+type WithFunctions<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
     [L in keyof F]: {
-        [C in keyof F[L]]: CommandSignature<REPLIES, F[L][C], M, F, S, RESP, FLAGS>;
+        [C in keyof F[L]]: CommandSignature<REPLIES, F[L][C], M, F, S, RESP, TYPE_MAPPING>;
     };
 };
-type WithScripts<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = {
-    [P in keyof S]: CommandSignature<REPLIES, S[P], M, F, S, RESP, FLAGS>;
+type WithScripts<REPLIES extends Array<unknown>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = {
+    [P in keyof S]: CommandSignature<REPLIES, S[P], M, F, S, RESP, TYPE_MAPPING>;
 };
-export type RedisClientMultiCommandType<REPLIES extends Array<any>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags> = (RedisClientMultiCommand<REPLIES> & WithCommands<REPLIES, M, F, S, RESP, FLAGS> & WithModules<REPLIES, M, F, S, RESP, FLAGS> & WithFunctions<REPLIES, M, F, S, RESP, FLAGS> & WithScripts<REPLIES, M, F, S, RESP, FLAGS>);
-type MULTI_REPLY = {
-    GENERIC: 'generic';
-    TYPED: 'typed';
-};
-type MultiReply = MULTI_REPLY[keyof MULTI_REPLY];
-type ReplyType<T extends MultiReply, REPLIES> = T extends MULTI_REPLY['TYPED'] ? REPLIES : Array<ReplyUnion>;
-export type RedisClientMultiExecutor = (queue: Array<RedisMultiQueuedCommand>, selectedDB?: number, chainId?: symbol) => Promise<Array<unknown>>;
-export default class RedisClientMultiCommand<REPLIES = []> extends RedisMultiCommand {
-    #private;
+export type RedisClientMultiCommandType<REPLIES extends Array<any>, M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = (RedisClientMultiCommand<REPLIES> & WithCommands<REPLIES, M, F, S, RESP, TYPE_MAPPING> & WithModules<REPLIES, M, F, S, RESP, TYPE_MAPPING> & WithFunctions<REPLIES, M, F, S, RESP, TYPE_MAPPING> & WithScripts<REPLIES, M, F, S, RESP, TYPE_MAPPING>);
+export default class RedisClientMultiCommand<REPLIES = []> {
+    private static _createCommand;
+    private static _createModuleCommand;
+    private static _createFunctionCommand;
+    private static _createScriptCommand;
     static extend<M extends RedisModules = Record<string, never>, F extends RedisFunctions = Record<string, never>, S extends RedisScripts = Record<string, never>, RESP extends RespVersions = 2>(config?: CommanderConfig<M, F, S, RESP>): any;
-    constructor(executor: RedisClientMultiExecutor, legacyMode?: boolean);
+    private readonly _multi;
+    private readonly _client;
+    private _selectedDB?;
+    constructor(client: RedisClientType);
     SELECT(db: number, transformReply?: TransformReply): this;
     select: (db: number, transformReply?: TransformReply) => this;
-    exec<T extends MultiReply = MULTI_REPLY['GENERIC']>(execAsPipeline?: boolean): Promise<ReplyType<T, REPLIES>>;
-    EXEC: <T extends MultiReply = "generic">(execAsPipeline?: boolean) => Promise<ReplyType<T, REPLIES>>;
+    addCommand(args: CommandArguments, transformReply?: TransformReply): this;
+    exec<T extends MultiReply = MULTI_REPLY['GENERIC']>(execAsPipeline?: boolean): Promise<MultiReplyType<T, REPLIES>>;
+    EXEC: <T extends MultiReply = "generic">(execAsPipeline?: boolean) => Promise<MultiReplyType<T, REPLIES>>;
     execTyped(execAsPipeline?: boolean): Promise<REPLIES>;
-    execAsPipeline<T extends MultiReply = MULTI_REPLY['GENERIC']>(): Promise<ReplyType<T, REPLIES>>;
+    execAsPipeline<T extends MultiReply = MULTI_REPLY['GENERIC']>(): Promise<MultiReplyType<T, REPLIES>>;
     execAsPipelineTyped(): Promise<REPLIES>;
 }
 export {};

dist/lib/client/multi-command.js

 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _a, _RedisClientMultiCommand_createCommand, _RedisClientMultiCommand_createModuleCommand, _RedisClientMultiCommand_createFunctionCommand, _RedisClientMultiCommand_createScriptCommand, _RedisClientMultiCommand_executor, _RedisClientMultiCommand_selectedDB;
 Object.defineProperty(exports, "__esModule", { value: true });
-const commands_1 = require("../commands");
-const multi_command_1 = require("../multi-command");
+const commands_1 = __importDefault(require("../commands"));
+const multi_command_1 = __importDefault(require("../multi-command"));
 const commander_1 = require("../commander");
-class RedisClientMultiCommand extends multi_command_1.default {
+class RedisClientMultiCommand {
+    static _createCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            return this.addCommand(command.transformArguments(...args), transformReply);
+        };
+    }
+    static _createModuleCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            return this.self.addCommand(command.transformArguments(...args), transformReply);
+        };
+    }
+    static _createFunctionCommand(name, fn, resp) {
+        const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn), transformReply = (0, commander_1.getTransformReply)(fn, resp);
+        return function (...args) {
+            const fnArgs = fn.transformArguments(...args), redisArgs = prefix.concat(fnArgs);
+            redisArgs.preserve = fnArgs.preserve;
+            return this.self.addCommand(redisArgs, transformReply);
+        };
+    }
+    static _createScriptCommand(script, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(script, resp);
+        return function (...args) {
+            this._multi.addScript(script, script.transformArguments(...args), transformReply);
+            return this;
+        };
+    }
     static extend(config) {
@@ -23,78 +41,28 @@ return (0, commander_1.attachConfig)({
             commands: commands_1.default,
-            createCommand: __classPrivateFieldGet(RedisClientMultiCommand, _a, "m", _RedisClientMultiCommand_createCommand),
-            createModuleCommand: __classPrivateFieldGet(RedisClientMultiCommand, _a, "m", _RedisClientMultiCommand_createModuleCommand),
-            createFunctionCommand: __classPrivateFieldGet(RedisClientMultiCommand, _a, "m", _RedisClientMultiCommand_createFunctionCommand),
-            createScriptCommand: __classPrivateFieldGet(RedisClientMultiCommand, _a, "m", _RedisClientMultiCommand_createScriptCommand),
+            createCommand: RedisClientMultiCommand._createCommand,
+            createModuleCommand: RedisClientMultiCommand._createModuleCommand,
+            createFunctionCommand: RedisClientMultiCommand._createFunctionCommand,
+            createScriptCommand: RedisClientMultiCommand._createScriptCommand,
             config
         });
     }
-    constructor(executor, legacyMode = false) {
-        super();
-        // readonly #multi = new RedisMultiCommand();
-        _RedisClientMultiCommand_executor.set(this, void 0);
-        // readonly v4: Record<string, any> = {};
-        _RedisClientMultiCommand_selectedDB.set(this, void 0);
-        Object.defineProperty(this, "select", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SELECT
-        });
-        Object.defineProperty(this, "EXEC", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.exec
-        });
-        __classPrivateFieldSet(this, _RedisClientMultiCommand_executor, executor, "f");
-        // if (legacyMode) {
-        //   this.#legacyMode();
-        // }
+    constructor(client) {
+        this._multi = new multi_command_1.default();
+        this.select = this.SELECT;
+        this.EXEC = this.exec;
+        this._client = client;
     }
-    // #legacyMode(): void {
-    //   this.v4.addCommand = this.addCommand.bind(this);
-    //   (this as any).addCommand = (...args: Array<any>): this => {
-    //     this.#multi.addCommand(transformLegacyCommandArguments(args));
-    //     return this;
-    //   };
-    //   this.v4.exec = this.exec.bind(this);
-    //   (this as any).exec = (callback?: (err: Error | null, replies?: Array<unknown>) => unknown): void => {
-    //     this.v4.exec()
-    //       .then((reply: Array<unknown>) => {
-    //         if (!callback) return;
-    //         callback(null, reply);
-    //       })
-    //       .catch((err: Error) => {
-    //         if (!callback) {
-    //           // this.emit('error', err);
-    //           return;
-    //         }
-    //         callback(err);
-    //       });
-    //   };
-    //   for (const [name, command] of Object.entries(COMMANDS as RedisCommands)) {
-    //     this.#defineLegacyCommand(name, command);
-    //     (this as any)[name.toLowerCase()] ??= (this as any)[name];
-    //   }
-    // }
-    // #defineLegacyCommand(this: any, name: string, command?: RedisCommand): void {
-    //   this.v4[name] = this[name].bind(this.v4);
-    //   this[name] = command && command.TRANSFORM_LEGACY_REPLY && command.transformReply ?
-    //     (...args: Array<unknown>) => {
-    //       this.#multi.addCommand(
-    //         [name, ...transformLegacyCommandArguments(args)],
-    //         command.transformReply
-    //       );
-    //       return this;
-    //     } :
-    //     (...args: Array<unknown>) => this.addCommand(name, ...args);
-    // }
     SELECT(db, transformReply) {
-        __classPrivateFieldSet(this, _RedisClientMultiCommand_selectedDB, db, "f");
-        return this.addCommand(['SELECT', db.toString()], transformReply);
+        this._selectedDB = db;
+        this._multi.addCommand(['SELECT', db.toString()], transformReply);
+        return this;
     }
+    addCommand(args, transformReply) {
+        this._multi.addCommand(args, transformReply);
+        return this;
+    }
     async exec(execAsPipeline = false) {
         if (execAsPipeline)
             return this.execAsPipeline();
-        return this.handleExecReplies(await __classPrivateFieldGet(this, _RedisClientMultiCommand_executor, "f").call(this, this.queue, __classPrivateFieldGet(this, _RedisClientMultiCommand_selectedDB, "f"), multi_command_1.default.generateChainId()));
+        return this._multi.transformReplies(await this._client.executeMulti(this._multi.queue, this._selectedDB));
     }
@@ -105,5 +73,5 @@ execTyped(execAsPipeline = false) {
     async execAsPipeline() {
-        if (this.queue.length === 0)
+        if (this._multi.queue.length === 0)
             return [];
-        return this.transformReplies(await __classPrivateFieldGet(this, _RedisClientMultiCommand_executor, "f").call(this, this.queue, __classPrivateFieldGet(this, _RedisClientMultiCommand_selectedDB, "f")));
+        return this._multi.transformReplies(await this._client.executePipeline(this._multi.queue));
     }
@@ -115,24 +83,1 @@ execAsPipelineTyped() {
 exports.default = RedisClientMultiCommand;
-_a = RedisClientMultiCommand, _RedisClientMultiCommand_executor = new WeakMap(), _RedisClientMultiCommand_selectedDB = new WeakMap(), _RedisClientMultiCommand_createCommand = function _RedisClientMultiCommand_createCommand(command, resp) {
-    const transformReply = (0, commander_1.getTransformReply)(command, resp);
-    return function () {
-        return this.addCommand(command.transformArguments.apply(undefined, arguments), transformReply);
-    };
-}, _RedisClientMultiCommand_createModuleCommand = function _RedisClientMultiCommand_createModuleCommand(command, resp) {
-    const transformReply = (0, commander_1.getTransformReply)(command, resp);
-    return function () {
-        return this.self.addCommand(command.transformArguments.apply(undefined, arguments), transformReply);
-    };
-}, _RedisClientMultiCommand_createFunctionCommand = function _RedisClientMultiCommand_createFunctionCommand(name, fn, resp) {
-    const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn), transformReply = (0, commander_1.getTransformReply)(fn, resp);
-    return function () {
-        const fnArgs = fn.transformArguments.apply(undefined, arguments), args = prefix.concat(fnArgs);
-        args.preserve = fnArgs.preserve;
-        return this.self.addCommand(args, transformReply);
-    };
-}, _RedisClientMultiCommand_createScriptCommand = function _RedisClientMultiCommand_createScriptCommand(script, resp) {
-    const transformReply = (0, commander_1.getTransformReply)(script, resp);
-    return function () {
-        return this.addScript(script, script.transformArguments.apply(undefined, arguments), transformReply);
-    };
-};

dist/lib/client/pub-sub.d.ts

 /// <reference types="node" />
-import { RedisArgument } from "../RESP/types";
+import { RedisArgument } from '../RESP/types';
 export declare enum PubSubType {
@@ -4,0 +4,0 @@ CHANNELS = "CHANNELS",

dist/lib/client/pub-sub.js

@@ -21,3 +21,3 @@ "use strict";
     PubSubType["SHARDED"] = "SHARDED";
-})(PubSubType = exports.PubSubType || (exports.PubSubType = {}));
+})(PubSubType || (exports.PubSubType = PubSubType = {}));
 const COMMANDS = {
@@ -24,0 +24,0 @@ [PubSubType.CHANNELS]: {

dist/lib/client/socket.d.ts

@@ -22,3 +22,3 @@ /// <reference types="node" />
     /**
-     * When the socket closes unexpectedly (without calling `.quit()`/`.disconnect()`), the client uses `reconnectStrategy` to decide what to do. The following values are supported:
+     * When the socket closes unexpectedly (without calling `.close()`/`.destroy()`), the client uses `reconnectStrategy` to decide what to do. The following values are supported:
      * 1. `false` -> do not reconnect, close the client and flush the command queue.
@@ -40,12 +40,26 @@ * 2. `number` -> wait for `X` milliseconds before reconnecting.
 export default class RedisSocket extends EventEmitter {
-    #private;
+    private static _initiateOptions;
+    private static _isTlsSocket;
+    private readonly _initiator;
+    private readonly _options;
+    private _socket?;
+    private _isOpen;
     get isOpen(): boolean;
+    private _isReady;
     get isReady(): boolean;
-    get writableNeedDrain(): boolean;
+    private _isSocketUnrefed;
     constructor(initiator: RedisSocketInitiator, options?: RedisSocketOptions);
+    private _reconnectStrategy;
+    private _shouldReconnect;
     connect(): Promise<void>;
-    writeCommand(args: Array<RedisArgument>): void;
-    disconnect(): void;
+    private _connect;
+    private _createSocket;
+    private _createNetSocket;
+    private _createTlsSocket;
+    private _onSocketError;
+    write(iterator: IterableIterator<Array<RedisArgument>>): void;
     quit<T>(fn: () => Promise<T>): Promise<T>;
-    cork(): void;
+    close(): void;
+    destroy(): void;
+    destroySocket(): void;
     ref(): void;
@@ -52,0 +66,0 @@ unref(): void;

dist/lib/client/socket.js

 "use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _RedisSocket_instances, _a, _RedisSocket_initiateOptions, _RedisSocket_isTlsSocket, _RedisSocket_initiator, _RedisSocket_options, _RedisSocket_socket, _RedisSocket_isOpen, _RedisSocket_isReady, _RedisSocket_writableNeedDrain, _RedisSocket_isSocketUnrefed, _RedisSocket_reconnectStrategy, _RedisSocket_shouldReconnect, _RedisSocket_connect, _RedisSocket_createSocket, _RedisSocket_createNetSocket, _RedisSocket_createTlsSocket, _RedisSocket_onSocketError, _RedisSocket_disconnect, _RedisSocket_isCorked;
 Object.defineProperty(exports, "__esModule", { value: true });
 const events_1 = require("events");
-const net = require("net");
-const tls = require("tls");
+const net = __importStar(require("net"));
+const tls = __importStar(require("tls"));
 const errors_1 = require("../errors");
-const utils_1 = require("../utils");
+const promises_1 = require("timers/promises");
 class RedisSocket extends events_1.EventEmitter {
+    static _initiateOptions(options) {
+        options ??= {};
+        if (!options.path) {
+            options.port ??= 6379;
+            options.host ??= 'localhost';
+        }
+        options.connectTimeout ??= 5000;
+        options.keepAlive ??= 5000;
+        options.noDelay ??= true;
+        return options;
+    }
+    static _isTlsSocket(options) {
+        return options.tls === true;
+    }
     get isOpen() {
-        return __classPrivateFieldGet(this, _RedisSocket_isOpen, "f");
+        return this._isOpen;
     }
     get isReady() {
-        return __classPrivateFieldGet(this, _RedisSocket_isReady, "f");
+        return this._isReady;
     }
-    get writableNeedDrain() {
-        return __classPrivateFieldGet(this, _RedisSocket_writableNeedDrain, "f");
-    }
     constructor(initiator, options) {
         super();
-        _RedisSocket_instances.add(this);
-        _RedisSocket_initiator.set(this, void 0);
-        _RedisSocket_options.set(this, void 0);
-        _RedisSocket_socket.set(this, void 0);
-        _RedisSocket_isOpen.set(this, false);
-        _RedisSocket_isReady.set(this, false);
-        // `writable.writableNeedDrain` was added in v15.2.0 and therefore can't be used
-        // https://nodejs.org/api/stream.html#stream_writable_writableneeddrain
-        _RedisSocket_writableNeedDrain.set(this, false);
-        _RedisSocket_isSocketUnrefed.set(this, false);
-        _RedisSocket_isCorked.set(this, false);
-        __classPrivateFieldSet(this, _RedisSocket_initiator, initiator, "f");
-        __classPrivateFieldSet(this, _RedisSocket_options, __classPrivateFieldGet(RedisSocket, _a, "m", _RedisSocket_initiateOptions).call(RedisSocket, options), "f");
+        this._isOpen = false;
+        this._isReady = false;
+        this._isSocketUnrefed = false;
+        this._initiator = initiator;
+        this._options = RedisSocket._initiateOptions(options);
     }
+    _reconnectStrategy(retries, cause) {
+        if (this._options.reconnectStrategy === false) {
+            return false;
+        }
+        else if (typeof this._options.reconnectStrategy === 'number') {
+            return this._options.reconnectStrategy;
+        }
+        else if (this._options.reconnectStrategy) {
+            try {
+                const retryIn = this._options.reconnectStrategy(retries, cause);
+                if (retryIn !== false && !(retryIn instanceof Error) && typeof retryIn !== 'number') {
+                    throw new TypeError(`Reconnect strategy should return \`false | Error | number\`, got ${retryIn} instead`);
+                }
+                return retryIn;
+            }
+            catch (err) {
+                this.emit('error', err);
+            }
+        }
+        return Math.min(retries * 50, 500);
+    }
+    _shouldReconnect(retries, cause) {
+        const retryIn = this._reconnectStrategy(retries, cause);
+        if (retryIn === false) {
+            this._isOpen = false;
+            this.emit('error', cause);
+            return cause;
+        }
+        else if (retryIn instanceof Error) {
+            this._isOpen = false;
+            this.emit('error', cause);
+            return new errors_1.ReconnectStrategyError(retryIn, cause);
+        }
+        return retryIn;
+    }
     async connect() {
-        if (__classPrivateFieldGet(this, _RedisSocket_isOpen, "f")) {
+        if (this._isOpen) {
             throw new Error('Socket already opened');
         }
-        __classPrivateFieldSet(this, _RedisSocket_isOpen, true, "f");
-        return __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_connect).call(this);
+        this._isOpen = true;
+        return this._connect();
     }
-    writeCommand(args) {
-        if (!__classPrivateFieldGet(this, _RedisSocket_socket, "f")) {
+    async _connect() {
+        let retries = 0;
+        do {
+            try {
+                this._socket = await this._createSocket();
+                this.emit('connect');
+                try {
+                    await this._initiator();
+                }
+                catch (err) {
+                    this._socket.destroy();
+                    this._socket = undefined;
+                    throw err;
+                }
+                this._isReady = true;
+                this.emit('ready');
+            }
+            catch (err) {
+                const retryIn = this._shouldReconnect(retries++, err);
+                if (typeof retryIn !== 'number') {
+                    throw retryIn;
+                }
+                this.emit('error', err);
+                await (0, promises_1.setTimeout)(retryIn);
+                this.emit('reconnecting');
+            }
+        } while (this._isOpen && !this._isReady);
+    }
+    _createSocket() {
+        return new Promise((resolve, reject) => {
+            const { connectEvent, socket } = RedisSocket._isTlsSocket(this._options) ?
+                this._createTlsSocket() :
+                this._createNetSocket();
+            if (this._options.connectTimeout) {
+                socket.setTimeout(this._options.connectTimeout, () => socket.destroy(new errors_1.ConnectionTimeoutError()));
+            }
+            if (this._isSocketUnrefed) {
+                socket.unref();
+            }
+            socket
+                .setNoDelay(this._options.noDelay)
+                .once('error', reject)
+                .once(connectEvent, () => {
+                socket
+                    .setTimeout(0)
+                    // https://github.com/nodejs/node/issues/31663
+                    .setKeepAlive(this._options.keepAlive !== false, this._options.keepAlive || 0)
+                    .off('error', reject)
+                    .once('error', (err) => this._onSocketError(err))
+                    .once('close', hadError => {
+                    if (!hadError && this._isOpen && this._socket === socket) {
+                        this._onSocketError(new errors_1.SocketClosedUnexpectedlyError());
+                    }
+                })
+                    .on('drain', () => this.emit('drain'))
+                    .on('data', data => this.emit('data', data));
+                resolve(socket);
+            });
+        });
+    }
+    _createNetSocket() {
+        return {
+            connectEvent: 'connect',
+            socket: net.connect(this._options) // TODO
+        };
+    }
+    _createTlsSocket() {
+        return {
+            connectEvent: 'secureConnect',
+            socket: tls.connect(this._options) // TODO
+        };
+    }
+    _onSocketError(err) {
+        this._isReady = false;
+        this.emit('error', err);
+        if (!this._isOpen || typeof this._shouldReconnect(0, err) !== 'number')
+            return;
+        this.emit('reconnecting');
+        this._connect().catch(() => {
+            // the error was already emitted, silently ignore it
+        });
+    }
+    write(iterator) {
+        if (!this._socket) {
             throw new errors_1.ClientClosedError();
         }
-        for (const toWrite of args) {
-            __classPrivateFieldSet(this, _RedisSocket_writableNeedDrain, !__classPrivateFieldGet(this, _RedisSocket_socket, "f").write(toWrite), "f");
+        this._socket.cork();
+        for (const args of iterator) {
+            for (const toWrite of args) {
+                this._socket.write(toWrite);
+            }
+            if (this._socket.writableNeedDrain)
+                break;
         }
+        this._socket.uncork();
     }
-    disconnect() {
-        if (!__classPrivateFieldGet(this, _RedisSocket_isOpen, "f")) {
-            throw new errors_1.ClientClosedError();
-        }
-        __classPrivateFieldSet(this, _RedisSocket_isOpen, false, "f");
-        __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_disconnect).call(this);
-    }
     async quit(fn) {
-        if (!__classPrivateFieldGet(this, _RedisSocket_isOpen, "f")) {
+        if (!this._isOpen) {
             throw new errors_1.ClientClosedError();
         }
-        __classPrivateFieldSet(this, _RedisSocket_isOpen, false, "f");
+        this._isOpen = false;
         const reply = await fn();
-        __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_disconnect).call(this);
+        this.destroySocket();
         return reply;
     }
-    cork() {
-        if (!__classPrivateFieldGet(this, _RedisSocket_socket, "f") || __classPrivateFieldGet(this, _RedisSocket_isCorked, "f")) {
-            return;
+    close() {
+        if (!this._isOpen) {
+            throw new errors_1.ClientClosedError();
         }
-        __classPrivateFieldGet(this, _RedisSocket_socket, "f").cork();
-        __classPrivateFieldSet(this, _RedisSocket_isCorked, true, "f");
-        queueMicrotask(() => {
-            __classPrivateFieldGet(this, _RedisSocket_socket, "f")?.uncork();
-            __classPrivateFieldSet(this, _RedisSocket_isCorked, false, "f");
-        });
+        this._isOpen = false;
     }
+    destroy() {
+        if (!this._isOpen) {
+            throw new errors_1.ClientClosedError();
+        }
+        this._isOpen = false;
+        this.destroySocket();
+    }
+    destroySocket() {
+        this._isReady = false;
+        if (this._socket) {
+            this._socket.destroy();
+            this._socket = undefined;
+        }
+        this.emit('end');
+    }
     ref() {
-        __classPrivateFieldSet(this, _RedisSocket_isSocketUnrefed, false, "f");
-        __classPrivateFieldGet(this, _RedisSocket_socket, "f")?.ref();
+        this._isSocketUnrefed = false;
+        this._socket?.ref();
     }
     unref() {
-        __classPrivateFieldSet(this, _RedisSocket_isSocketUnrefed, true, "f");
-        __classPrivateFieldGet(this, _RedisSocket_socket, "f")?.unref();
+        this._isSocketUnrefed = true;
+        this._socket?.unref();
     }
 }
 exports.default = RedisSocket;
-_a = RedisSocket, _RedisSocket_initiator = new WeakMap(), _RedisSocket_options = new WeakMap(), _RedisSocket_socket = new WeakMap(), _RedisSocket_isOpen = new WeakMap(), _RedisSocket_isReady = new WeakMap(), _RedisSocket_writableNeedDrain = new WeakMap(), _RedisSocket_isSocketUnrefed = new WeakMap(), _RedisSocket_isCorked = new WeakMap(), _RedisSocket_instances = new WeakSet(), _RedisSocket_initiateOptions = function _RedisSocket_initiateOptions(options) {
-    options ??= {};
-    if (!options.path) {
-        options.port ??= 6379;
-        options.host ??= 'localhost';
-    }
-    options.connectTimeout ??= 5000;
-    options.keepAlive ??= 5000;
-    options.noDelay ??= true;
-    return options;
-}, _RedisSocket_isTlsSocket = function _RedisSocket_isTlsSocket(options) {
-    return options.tls === true;
-}, _RedisSocket_reconnectStrategy = function _RedisSocket_reconnectStrategy(retries, cause) {
-    if (__classPrivateFieldGet(this, _RedisSocket_options, "f").reconnectStrategy === false) {
-        return false;
-    }
-    else if (typeof __classPrivateFieldGet(this, _RedisSocket_options, "f").reconnectStrategy === 'number') {
-        return __classPrivateFieldGet(this, _RedisSocket_options, "f").reconnectStrategy;
-    }
-    else if (__classPrivateFieldGet(this, _RedisSocket_options, "f").reconnectStrategy) {
-        try {
-            const retryIn = __classPrivateFieldGet(this, _RedisSocket_options, "f").reconnectStrategy(retries, cause);
-            if (retryIn !== false && !(retryIn instanceof Error) && typeof retryIn !== 'number') {
-                throw new TypeError(`Reconnect strategy should return \`false | Error | number\`, got ${retryIn} instead`);
-            }
-            return retryIn;
-        }
-        catch (err) {
-            this.emit('error', err);
-        }
-    }
-    return Math.min(retries * 50, 500);
-}, _RedisSocket_shouldReconnect = function _RedisSocket_shouldReconnect(retries, cause) {
-    const retryIn = __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_reconnectStrategy).call(this, retries, cause);
-    if (retryIn === false) {
-        __classPrivateFieldSet(this, _RedisSocket_isOpen, false, "f");
-        this.emit('error', cause);
-        return cause;
-    }
-    else if (retryIn instanceof Error) {
-        __classPrivateFieldSet(this, _RedisSocket_isOpen, false, "f");
-        this.emit('error', cause);
-        return new errors_1.ReconnectStrategyError(retryIn, cause);
-    }
-    return retryIn;
-}, _RedisSocket_connect = async function _RedisSocket_connect() {
-    let retries = 0;
-    do {
-        try {
-            __classPrivateFieldSet(this, _RedisSocket_socket, await __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_createSocket).call(this), "f");
-            __classPrivateFieldSet(this, _RedisSocket_writableNeedDrain, false, "f");
-            this.emit('connect');
-            try {
-                await __classPrivateFieldGet(this, _RedisSocket_initiator, "f").call(this);
-            }
-            catch (err) {
-                __classPrivateFieldGet(this, _RedisSocket_socket, "f").destroy();
-                __classPrivateFieldSet(this, _RedisSocket_socket, undefined, "f");
-                throw err;
-            }
-            __classPrivateFieldSet(this, _RedisSocket_isReady, true, "f");
-            this.emit('ready');
-        }
-        catch (err) {
-            const retryIn = __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_shouldReconnect).call(this, retries++, err);
-            if (typeof retryIn !== 'number') {
-                throw retryIn;
-            }
-            this.emit('error', err);
-            await (0, utils_1.promiseTimeout)(retryIn);
-            this.emit('reconnecting');
-        }
-    } while (__classPrivateFieldGet(this, _RedisSocket_isOpen, "f") && !__classPrivateFieldGet(this, _RedisSocket_isReady, "f"));
-}, _RedisSocket_createSocket = function _RedisSocket_createSocket() {
-    return new Promise((resolve, reject) => {
-        const { connectEvent, socket } = __classPrivateFieldGet(RedisSocket, _a, "m", _RedisSocket_isTlsSocket).call(RedisSocket, __classPrivateFieldGet(this, _RedisSocket_options, "f")) ?
-            __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_createTlsSocket).call(this) :
-            __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_createNetSocket).call(this);
-        if (__classPrivateFieldGet(this, _RedisSocket_options, "f").connectTimeout) {
-            socket.setTimeout(__classPrivateFieldGet(this, _RedisSocket_options, "f").connectTimeout, () => socket.destroy(new errors_1.ConnectionTimeoutError()));
-        }
-        if (__classPrivateFieldGet(this, _RedisSocket_isSocketUnrefed, "f")) {
-            socket.unref();
-        }
-        socket
-            .setNoDelay(__classPrivateFieldGet(this, _RedisSocket_options, "f").noDelay)
-            .once('error', reject)
-            .once(connectEvent, () => {
-            socket
-                .setTimeout(0)
-                // https://github.com/nodejs/node/issues/31663
-                .setKeepAlive(__classPrivateFieldGet(this, _RedisSocket_options, "f").keepAlive !== false, __classPrivateFieldGet(this, _RedisSocket_options, "f").keepAlive || 0)
-                .off('error', reject)
-                .once('error', (err) => __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_onSocketError).call(this, err))
-                .once('close', hadError => {
-                if (!hadError && __classPrivateFieldGet(this, _RedisSocket_isOpen, "f") && __classPrivateFieldGet(this, _RedisSocket_socket, "f") === socket) {
-                    __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_onSocketError).call(this, new errors_1.SocketClosedUnexpectedlyError());
-                }
-            })
-                .on('drain', () => {
-                __classPrivateFieldSet(this, _RedisSocket_writableNeedDrain, false, "f");
-                this.emit('drain');
-            })
-                .on('data', data => this.emit('data', data));
-            resolve(socket);
-        });
-    });
-}, _RedisSocket_createNetSocket = function _RedisSocket_createNetSocket() {
-    return {
-        connectEvent: 'connect',
-        socket: net.connect(__classPrivateFieldGet(this, _RedisSocket_options, "f")) // TODO
-    };
-}, _RedisSocket_createTlsSocket = function _RedisSocket_createTlsSocket() {
-    return {
-        connectEvent: 'secureConnect',
-        socket: tls.connect(__classPrivateFieldGet(this, _RedisSocket_options, "f")) // TODO
-    };
-}, _RedisSocket_onSocketError = function _RedisSocket_onSocketError(err) {
-    __classPrivateFieldSet(this, _RedisSocket_isReady, false, "f");
-    this.emit('error', err);
-    if (!__classPrivateFieldGet(this, _RedisSocket_isOpen, "f") || typeof __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_shouldReconnect).call(this, 0, err) !== 'number')
-        return;
-    this.emit('reconnecting');
-    __classPrivateFieldGet(this, _RedisSocket_instances, "m", _RedisSocket_connect).call(this).catch(() => {
-        // the error was already emitted, silently ignore it
-    });
-}, _RedisSocket_disconnect = function _RedisSocket_disconnect() {
-    __classPrivateFieldSet(this, _RedisSocket_isReady, false, "f");
-    if (__classPrivateFieldGet(this, _RedisSocket_socket, "f")) {
-        __classPrivateFieldGet(this, _RedisSocket_socket, "f").destroy();
-        __classPrivateFieldSet(this, _RedisSocket_socket, undefined, "f");
-    }
-    this.emit('end');
-};

dist/lib/cluster/cluster-slots.d.ts

@@ -21,2 +21,3 @@ /// <reference types="node" />
 export interface ShardNode<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions> extends Node<M, F, S, RESP> {
+    id: string;
     host: string;
@@ -64,4 +65,13 @@ port: number;
     private _rediscover;
+    /**
+     * @deprecated Use `close` instead.
+     */
     quit(): Promise<void>;
+    /**
+     * @deprecated Use `destroy` instead.
+     */
     disconnect(): Promise<void>;
+    close(): Promise<void>;
+    destroy(): void;
+    private _clients;
     private _destroy;
@@ -68,0 +78,0 @@ private _execOnNodeClient;

dist/lib/cluster/cluster-slots.js

@@ -13,6 +13,9 @@ "use strict";
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _RedisClusterSlots_instances, _RedisClusterSlots_runningRediscoverPromise, _RedisClusterSlots_initiateShardedPubSubClient;
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("../errors");
-const client_1 = require("../client");
+const client_1 = __importDefault(require("../client"));
 const util_1 = require("util");
@@ -31,69 +34,9 @@ const pub_sub_1 = require("../client/pub-sub");
         _RedisClusterSlots_instances.add(this);
-        Object.defineProperty(this, "_options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_clientFactory", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_emit", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "slots", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Array(RedisClusterSlots._SLOTS)
-        });
-        Object.defineProperty(this, "shards", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Array()
-        });
-        Object.defineProperty(this, "masters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Array()
-        });
-        Object.defineProperty(this, "replicas", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Array()
-        });
-        Object.defineProperty(this, "nodeByAddress", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "pubSubNode", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_isOpen", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
+        this.slots = new Array(RedisClusterSlots._SLOTS);
+        this.shards = new Array();
+        this.masters = new Array();
+        this.replicas = new Array();
+        this.nodeByAddress = new Map();
+        this._isOpen = false;
         _RedisClusterSlots_runningRediscoverPromise.set(this, void 0);
-        Object.defineProperty(this, "_randomNodeIterator", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this._options = options;
@@ -201,3 +144,3 @@ this._clientFactory = client_1.default.factory(options);
         finally {
-            await client.disconnect();
+            client.destroy();
         }
@@ -232,4 +175,4 @@ }
     }
-    _initiateSlotNode(slotAddress, readonly, eagerConnent, addressesInUse, promises) {
-        const address = `${slotAddress.host}:${slotAddress.port}`;
+    _initiateSlotNode(shard, readonly, eagerConnent, addressesInUse, promises) {
+        const address = `${shard.host}:${shard.port}`;
         addressesInUse.add(address);
@@ -239,3 +182,3 @@ let node = this.nodeByAddress.get(address);
             node = {
-                ...slotAddress,
+                ...shard,
                 address,
@@ -292,17 +235,36 @@ readonly,
     }
+    /**
+     * @deprecated Use `close` instead.
+     */
     quit() {
         return this._destroy(client => client.quit());
     }
+    /**
+     * @deprecated Use `destroy` instead.
+     */
     disconnect() {
         return this._destroy(client => client.disconnect());
     }
-    async _destroy(fn) {
+    close() {
+        return this._destroy(client => client.close());
+    }
+    destroy() {
         this._isOpen = false;
-        const promises = [];
+        for (const client of this._clients()) {
+            this._execOnNodeClient(client, client => client.destroy());
+        }
+        if (this.pubSubNode) {
+            this._execOnNodeClient(this.pubSubNode.client, client => client.destroy());
+            this.pubSubNode = undefined;
+        }
+        this._resetSlots();
+        this.nodeByAddress.clear();
+    }
+    *_clients() {
         for (const { master, replicas } of this.shards) {
             if (master.client) {
-                promises.push(this._execOnNodeClient(master.client, fn));
+                yield master.client;
             }
             if (master.pubSubClient) {
-                promises.push(this._execOnNodeClient(master.pubSubClient, fn));
+                yield master.pubSubClient;
             }
@@ -312,3 +274,3 @@ if (replicas) {
                     if (client) {
-                        promises.push(this._execOnNodeClient(client, fn));
+                        yield client;
                     }
@@ -318,2 +280,9 @@ }
         }
+    }
+    async _destroy(fn) {
+        this._isOpen = false;
+        const promises = [];
+        for (const client of this._clients()) {
+            promises.push(this._execOnNodeClient(client, fn));
+        }
         if (this.pubSubNode) {
@@ -432,3 +401,3 @@ promises.push(this._execOnNodeClient(this.pubSubNode.client, fn));
         if (!client.isPubSubActive) {
-            await client.disconnect();
+            client.destroy();
             this.pubSubNode = undefined;
@@ -476,8 +445,3 @@ }
 };
-Object.defineProperty(RedisClusterSlots, "_SLOTS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 16384
-});
+RedisClusterSlots._SLOTS = 16384;
 exports.default = RedisClusterSlots;

dist/lib/cluster/index.d.ts

 /// <reference types="node" />
-import { ClientCommandOptions, RedisClientOptions, RedisClientType } from '../client';
-import { CommandArguments, CommanderConfig, CommandPolicies, CommandWithPoliciesSignature, Flags, RedisArgument, RedisFunctions, RedisModules, RedisScripts, ReplyUnion, RespVersions } from '../RESP/types';
+import { RedisClientOptions } from '../client';
+import { CommandOptions } from '../client/commands-queue';
+import { Command, CommandArguments, CommanderConfig, CommandPolicies, CommandWithPoliciesSignature, TypeMapping, RedisArgument, RedisFunctions, RedisModules, RedisScripts, ReplyUnion, RespVersions } from '../RESP/types';
 import COMMANDS from '../commands';
 import { EventEmitter } from 'events';
 import { NodeAddressMap, ShardNode } from './cluster-slots';
+import { RedisClusterMultiCommandType } from './multi-command';
+import { RedisMultiQueuedCommand } from '../multi-command';
 import { PubSubListener } from '../client/pub-sub';
-export type RedisClusterClientOptions = Omit<RedisClientOptions, 'modules' | 'functions' | 'scripts' | 'database' | 'RESP'>;
-export interface RedisClusterOptions<M extends RedisModules = RedisModules, F extends RedisFunctions = RedisFunctions, S extends RedisScripts = RedisScripts, RESP extends RespVersions = RespVersions> extends CommanderConfig<M, F, S, RESP> {
+interface ClusterCommander<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping, POLICIES extends CommandPolicies> extends CommanderConfig<M, F, S, RESP> {
+    commandOptions?: ClusterCommandOptions<TYPE_MAPPING, POLICIES>;
+}
+export type RedisClusterClientOptions = Omit<RedisClientOptions, keyof ClusterCommander<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, CommandPolicies>>;
+export interface RedisClusterOptions<M extends RedisModules = RedisModules, F extends RedisFunctions = RedisFunctions, S extends RedisScripts = RedisScripts, RESP extends RespVersions = RespVersions, TYPE_MAPPING extends TypeMapping = TypeMapping, POLICIES extends CommandPolicies = CommandPolicies> extends ClusterCommander<M, F, S, RESP, TYPE_MAPPING, POLICIES> {
     /**
@@ -39,11 +45,11 @@ * Should contain details for some of the cluster nodes that the client will use to discover
 }
-type WithCommands<RESP extends RespVersions, FLAGS extends Flags, POLICIES extends CommandPolicies> = {
-    [P in keyof typeof COMMANDS]: CommandWithPoliciesSignature<(typeof COMMANDS)[P], RESP, FLAGS, POLICIES>;
+type WithCommands<RESP extends RespVersions, TYPE_MAPPING extends TypeMapping, POLICIES extends CommandPolicies> = {
+    [P in keyof typeof COMMANDS]: CommandWithPoliciesSignature<(typeof COMMANDS)[P], RESP, TYPE_MAPPING, POLICIES>;
 };
-export type RedisClusterType<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, FLAGS extends Flags = {}, POLICIES extends CommandPolicies = {}> = RedisCluster<M, F, S, RESP, FLAGS, POLICIES> & WithCommands<RESP, FLAGS, POLICIES>;
-export interface ClusterCommandOptions extends ClientCommandOptions {
-    policies?: CommandPolicies;
+export type RedisClusterType<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}, POLICIES extends CommandPolicies = {}> = RedisCluster<M, F, S, RESP, TYPE_MAPPING, POLICIES> & WithCommands<RESP, TYPE_MAPPING, POLICIES>;
+export interface ClusterCommandOptions<TYPE_MAPPING extends TypeMapping = TypeMapping, POLICIES extends CommandPolicies = CommandPolicies> extends CommandOptions<TYPE_MAPPING> {
+    policies?: POLICIES;
 }
-export default class RedisCluster<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, FLAGS extends Flags, POLICIES extends CommandPolicies> extends EventEmitter {
-    private static _extractFirstKey;
+export default class RedisCluster<M extends RedisModules, F extends RedisFunctions, S extends RedisScripts, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping, POLICIES extends CommandPolicies> extends EventEmitter {
+    static extractFirstKey<C extends Command>(command: C, args: Parameters<C['transformArguments']>, redisArgs: Array<RedisArgument>): RedisArgument | undefined;
     private static _createCommand;
@@ -53,6 +59,7 @@ private static _createModuleCommand;
     private static _createScriptCommand;
-    static factory<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2>(config?: CommanderConfig<M, F, S, RESP>): (options?: Omit<RedisClusterOptions, keyof Exclude<typeof config, undefined>>) => RedisClusterType<M, F, S, RESP, {}, {}>;
-    static create<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2>(options?: RedisClusterOptions<M, F, S, RESP>): RedisClusterType<M, F, S, RESP, {}, {}>;
+    static factory<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}, POLICIES extends CommandPolicies = {}>(config?: ClusterCommander<M, F, S, RESP, TYPE_MAPPING, POLICIES>): (options?: Omit<RedisClusterOptions, keyof Exclude<typeof config, undefined>>) => RedisClusterType<M, F, S, RESP, TYPE_MAPPING, POLICIES>;
+    static create<M extends RedisModules = {}, F extends RedisFunctions = {}, S extends RedisScripts = {}, RESP extends RespVersions = 2, TYPE_MAPPING extends TypeMapping = {}, POLICIES extends CommandPolicies = {}>(options?: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING, POLICIES>): RedisClusterType<M, F, S, RESP, TYPE_MAPPING, POLICIES>;
     private readonly _options;
     private readonly _slots;
+    private _commandOptions?;
     /**
@@ -88,11 +95,11 @@ * An array of the cluster slots, each slot contain its `master` and `replicas`.
     get isOpen(): boolean;
-    constructor(options: RedisClusterOptions<M, F, S, RESP>);
-    duplicate(overrides?: Partial<RedisClusterOptions<M, F, S>>): RedisClusterType<M, F, S>;
+    constructor(options: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING, POLICIES>);
+    duplicate<_M extends RedisModules = M, _F extends RedisFunctions = F, _S extends RedisScripts = S, _RESP extends RespVersions = RESP, _TYPE_MAPPING extends TypeMapping = TYPE_MAPPING>(overrides?: Partial<RedisClusterOptions<_M, _F, _S, _RESP, _TYPE_MAPPING>>): RedisClusterType<_M, _F, _S, _RESP, _TYPE_MAPPING, {}>;
     connect(): Promise<void>;
-    withCommandOptions<T extends ClusterCommandOptions>(options: T): RedisClusterType<M, F, S, RESP, T["flags"] extends Flags ? T["flags"] : {}, T["policies"] extends CommandPolicies ? T["policies"] : {}>;
+    withCommandOptions<OPTIONS extends ClusterCommandOptions<TYPE_MAPPING, CommandPolicies>, TYPE_MAPPING extends TypeMapping, POLICIES extends CommandPolicies>(options: OPTIONS): RedisClusterType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping ? TYPE_MAPPING : {}, POLICIES extends CommandPolicies ? POLICIES : {}>;
     private _commandOptionsProxy;
     /**
-     * Override the `flags` command option
+     * Override the `typeMapping` command option
      */
-    withFlags<FLAGS extends Flags>(flags: FLAGS): RedisClusterType<M, F, S, RESP, FLAGS extends Flags ? FLAGS : {}, POLICIES>;
+    withTypeMapping<TYPE_MAPPING extends TypeMapping>(typeMapping: TYPE_MAPPING): RedisClusterType<M, F, S, RESP, TYPE_MAPPING extends TypeMapping ? TYPE_MAPPING : {}, POLICIES>;
     /**
@@ -102,4 +109,14 @@ * Override the `policies` command option
      */
-    withPolicies<POLICIES extends CommandPolicies>(policies: POLICIES): RedisClusterType<M, F, S, RESP, FLAGS, POLICIES extends CommandPolicies ? POLICIES : {}>;
+    withPolicies<POLICIES extends CommandPolicies>(policies: POLICIES): RedisClusterType<M, F, S, RESP, TYPE_MAPPING, POLICIES extends CommandPolicies ? POLICIES : {}>;
     sendCommand<T = ReplyUnion>(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, args: CommandArguments, options?: ClusterCommandOptions, deafultPolicies?: CommandPolicies): Promise<T>;
+    /**
+     * @internal
+     */
+    executePipeline(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, commands: Array<RedisMultiQueuedCommand>): Promise<unknown[]>;
+    /**
+     * @internal
+     */
+    executeMulti(firstKey: RedisArgument | undefined, isReadonly: boolean | undefined, commands: Array<RedisMultiQueuedCommand>): Promise<unknown[]>;
+    MULTI(routing?: RedisArgument): RedisClusterMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>;
+    multi: (routing?: RedisArgument) => RedisClusterMultiCommandType<[], M, F, S, RESP, TYPE_MAPPING>;
     SUBSCRIBE<T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T): Promise<void>;
@@ -117,4 +134,13 @@ subscribe: <T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T | undefined) => Promise<void>;
     sUnsubscribe: <T extends boolean = false>(channels: string | Array<string>, listener: PubSubListener<T>, bufferMode?: T | undefined) => Promise<void>;
+    /**
+     * @deprecated Use `close` instead.
+     */
+    quit(): Promise<void>;
+    /**
+     * @deprecated Use `destroy` instead.
+     */
     disconnect(): Promise<void>;
-    nodeClient(node: ShardNode<M, F, S, RESP>): RedisClientType<M, F, S, RESP> | Promise<RedisClientType<M, F, S, RESP>>;
+    close(): Promise<void>;
+    destroy(): void;
+    nodeClient(node: ShardNode<M, F, S, RESP>): import("../client").RedisClientType<M, F, S, RESP> | Promise<import("../client").RedisClientType<M, F, S, RESP>>;
     /**
@@ -121,0 +147,0 @@ * Returns a random node from the cluster.

dist/lib/cluster/index.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const commands_1 = require("../commands");
+const commands_1 = __importDefault(require("../commands"));
 const events_1 = require("events");
 const commander_1 = require("../commander");
-const cluster_slots_1 = require("./cluster-slots");
+const cluster_slots_1 = __importDefault(require("./cluster-slots"));
+const multi_command_1 = __importDefault(require("./multi-command"));
 const errors_1 = require("../errors");
 class RedisCluster extends events_1.EventEmitter {
-    static _extractFirstKey(command, args, redisArgs) {
+    static extractFirstKey(command, args, redisArgs) {
         if (command.FIRST_KEY_INDEX === undefined) {
@@ -20,6 +24,6 @@ return undefined;
         const transformReply = (0, commander_1.getTransformReply)(command, resp);
-        return async function () {
-            const args = command.transformArguments.apply(undefined, arguments), firstKey = RedisCluster._extractFirstKey(command, arguments, args), reply = await this.sendCommand(firstKey, command.IS_READ_ONLY, args, this.commandOptions, command.POLICIES);
+        return async function (...args) {
+            const redisArgs = command.transformArguments(...args), firstKey = RedisCluster.extractFirstKey(command, args, redisArgs), reply = await this.sendCommand(firstKey, command.IS_READ_ONLY, redisArgs, this._commandOptions, command.POLICIES);
             return transformReply ?
-                transformReply(reply, args.preserve) :
+                transformReply(reply, redisArgs.preserve) :
                 reply;
@@ -30,6 +34,6 @@ };
         const transformReply = (0, commander_1.getTransformReply)(command, resp);
-        return async function () {
-            const args = command.transformArguments.apply(undefined, arguments), firstKey = RedisCluster._extractFirstKey(command, arguments, args), reply = await this.self.sendCommand(firstKey, command.IS_READ_ONLY, args, this.self.commandOptions, command.POLICIES);
+        return async function (...args) {
+            const redisArgs = command.transformArguments(...args), firstKey = RedisCluster.extractFirstKey(command, args, redisArgs), reply = await this.self.sendCommand(firstKey, command.IS_READ_ONLY, redisArgs, this.self._commandOptions, command.POLICIES);
             return transformReply ?
-                transformReply(reply, args.preserve) :
+                transformReply(reply, redisArgs.preserve) :
                 reply;
@@ -40,4 +44,4 @@ };
         const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn), transformReply = (0, commander_1.getTransformReply)(fn, resp);
-        return async function () {
-            const fnArgs = fn.transformArguments.apply(undefined, arguments), args = prefix.concat(fnArgs), firstKey = RedisCluster._extractFirstKey(fn, arguments, args), reply = await this.self.sendCommand(firstKey, fn.IS_READ_ONLY, args, this.self.commandOptions, fn.POLICIES);
+        return async function (...args) {
+            const fnArgs = fn.transformArguments(...args), redisArgs = prefix.concat(fnArgs), firstKey = RedisCluster.extractFirstKey(fn, fnArgs, redisArgs), reply = await this.self.sendCommand(firstKey, fn.IS_READ_ONLY, redisArgs, this.self._commandOptions, fn.POLICIES);
             return transformReply ?
@@ -50,4 +54,4 @@ transformReply(reply, fnArgs.preserve) :
         const prefix = (0, commander_1.scriptArgumentsPrefix)(script), transformReply = (0, commander_1.getTransformReply)(script, resp);
-        return async function () {
-            const scriptArgs = script.transformArguments.apply(undefined, arguments), args = prefix.concat(scriptArgs), firstKey = RedisCluster._extractFirstKey(script, arguments, args), reply = await this.sendCommand(firstKey, script.IS_READ_ONLY, args, this.commandOptions, script.POLICIES);
+        return async function (...args) {
+            const scriptArgs = script.transformArguments(...args), redisArgs = prefix.concat(scriptArgs), firstKey = RedisCluster.extractFirstKey(script, scriptArgs, redisArgs), reply = await this.sendCommand(firstKey, script.IS_READ_ONLY, redisArgs, this._commandOptions, script.POLICIES);
             return transformReply ?
@@ -68,3 +72,3 @@ transformReply(reply, scriptArgs.preserve) :
         });
-        // Client.prototype.Multi = RedisClientMultiCommand.extend(config);
+        Cluster.prototype.Multi = multi_command_1.default.extend(config);
         return (options) => {
@@ -120,3 +124,2 @@ // returning a proxy of the client to prevent the namespaces.self to leak between proxies
     }
-    // readonly #Multi: InstantiableRedisClusterMultiCommandType<M, F, S>;
     get isOpen() {
@@ -127,53 +130,14 @@ return this._slots.isOpen;
         super();
-        Object.defineProperty(this, "_options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_slots", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "subscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SUBSCRIBE
-        });
-        Object.defineProperty(this, "unsubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.UNSUBSCRIBE
-        });
-        Object.defineProperty(this, "pSubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.PSUBSCRIBE
-        });
-        Object.defineProperty(this, "pUnsubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.PUNSUBSCRIBE
-        });
-        Object.defineProperty(this, "sSubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SSUBSCRIBE
-        });
-        Object.defineProperty(this, "sUnsubscribe", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: this.SUNSUBSCRIBE
-        });
+        this.multi = this.MULTI;
+        this.subscribe = this.SUBSCRIBE;
+        this.unsubscribe = this.UNSUBSCRIBE;
+        this.pSubscribe = this.PSUBSCRIBE;
+        this.pUnsubscribe = this.PUNSUBSCRIBE;
+        this.sSubscribe = this.SSUBSCRIBE;
+        this.sUnsubscribe = this.SUNSUBSCRIBE;
         this._options = options;
         this._slots = new cluster_slots_1.default(options, this.emit.bind(this));
-        // this.#Multi = RedisClusterMultiCommand.extend(options);
+        if (options?.commandOptions) {
+            this._commandOptions = options.commandOptions;
+        }
     }
@@ -183,2 +147,3 @@ duplicate(overrides) {
             ...this._options,
+            commandOptions: this._commandOptions,
             ...overrides
@@ -192,3 +157,3 @@ });
         const proxy = Object.create(this);
-        proxy.commandOptions = options;
+        proxy._commandOptions = options;
         return proxy;
@@ -198,11 +163,11 @@ }
         const proxy = Object.create(this);
-        proxy.commandOptions = Object.create(this.commandOptions ?? null);
-        proxy.commandOptions[key] = value;
+        proxy._commandOptions = Object.create(this._commandOptions ?? null);
+        proxy._commandOptions[key] = value;
         return proxy;
     }
     /**
-     * Override the `flags` command option
+     * Override the `typeMapping` command option
      */
-    withFlags(flags) {
-        return this._commandOptionsProxy('flags', flags);
+    withTypeMapping(typeMapping) {
+        return this._commandOptionsProxy('typeMapping', typeMapping);
     }
@@ -253,15 +218,19 @@ /**
     }
-    // MULTI(routing?: RedisCommandArgument): RedisClusterMultiCommandType<M, F, S> {
-    //   return new this.#Multi(
-    //     (commands: Array<RedisMultiQueuedCommand>, firstKey?: RedisCommandArgument, chainId?: symbol) => {
-    //       return this.#execute(
-    //         firstKey,
-    //         false,
-    //         client => client.multiExecutor(commands, undefined, chainId)
-    //       );
-    //     },
-    //     routing
-    //   );
-    // }
-    // multi = this.MULTI;
+    /**
+     * @internal
+     */
+    async executePipeline(firstKey, isReadonly, commands) {
+        const client = await this._slots.getClient(firstKey, isReadonly);
+        return client.executePipeline(commands);
+    }
+    /**
+     * @internal
+     */
+    async executeMulti(firstKey, isReadonly, commands) {
+        const client = await this._slots.getClient(firstKey, isReadonly);
+        return client.executeMulti(commands);
+    }
+    MULTI(routing) {
+        return new this.Multi(this, routing);
+    }
     async SUBSCRIBE(channels, listener, bufferMode) {
@@ -304,8 +273,20 @@ return (await this._slots.getPubSubClient())
     }
-    // quit(): Promise<void> {
-    //   return this.#slots.quit();
-    // }
+    /**
+     * @deprecated Use `close` instead.
+     */
+    quit() {
+        return this._slots.quit();
+    }
+    /**
+     * @deprecated Use `destroy` instead.
+     */
     disconnect() {
         return this._slots.disconnect();
     }
+    close() {
+        return this._slots.close();
+    }
+    destroy() {
+        return this._slots.destroy();
+    }
     nodeClient(node) {
@@ -312,0 +293,0 @@ return this._slots.nodeClient(node);

dist/lib/cluster/multi-command.js

 "use strict";
-// import COMMANDS from './commands';
-// import { RedisCommand, RedisCommandArgument, RedisCommandArguments, RedisCommandRawReply, RedisFunctions, RedisModules, RedisExtensions, RedisScript, RedisScripts, ExcludeMappedString, RedisFunction } from '../commands';
-// import RedisMultiCommand, { RedisMultiQueuedCommand } from '../multi-command';
-// import { attachCommands, attachExtensions } from '../commander';
-// import RedisCluster from '.';
-// type RedisClusterMultiCommandSignature<
-//     C extends RedisCommand,
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = (...args: Parameters<C['transformArguments']>) => RedisClusterMultiCommandType<M, F, S>;
-// type WithCommands<
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = {
-//     [P in keyof typeof COMMANDS]: RedisClusterMultiCommandSignature<(typeof COMMANDS)[P], M, F, S>;
-// };
-// type WithModules<
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = {
-//     [P in keyof M as ExcludeMappedString<P>]: {
-//         [C in keyof M[P] as ExcludeMappedString<C>]: RedisClusterMultiCommandSignature<M[P][C], M, F, S>;
-//     };
-// };
-// type WithFunctions<
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = {
-//     [P in keyof F as ExcludeMappedString<P>]: {
-//         [FF in keyof F[P] as ExcludeMappedString<FF>]: RedisClusterMultiCommandSignature<F[P][FF], M, F, S>;
-//     };
-// };
-// type WithScripts<
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = {
-//     [P in keyof S as ExcludeMappedString<P>]: RedisClusterMultiCommandSignature<S[P], M, F, S>;
-// };
-// export type RedisClusterMultiCommandType<
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = RedisClusterMultiCommand & WithCommands<M, F, S> & WithModules<M, F, S> & WithFunctions<M, F, S> & WithScripts<M, F, S>;
-// export type InstantiableRedisClusterMultiCommandType<
-//     M extends RedisModules,
-//     F extends RedisFunctions,
-//     S extends RedisScripts
-// > = new (...args: ConstructorParameters<typeof RedisClusterMultiCommand>) => RedisClusterMultiCommandType<M, F, S>;
-// export type RedisClusterMultiExecutor = (queue: Array<RedisMultiQueuedCommand>, firstKey?: RedisCommandArgument, chainId?: symbol) => Promise<Array<RedisCommandRawReply>>;
-// export default class RedisClusterMultiCommand {
-//     readonly #multi = new RedisMultiCommand();
-//     readonly #executor: RedisClusterMultiExecutor;
-//     #firstKey: RedisCommandArgument | undefined;
-//     static extend<
-//         M extends RedisModules,
-//         F extends RedisFunctions,
-//         S extends RedisScripts
-//     >(extensions?: RedisExtensions<M, F, S>): InstantiableRedisClusterMultiCommandType<M, F, S> {
-//         return attachExtensions({
-//             BaseClass: RedisClusterMultiCommand,
-//             modulesExecutor: RedisClusterMultiCommand.prototype.commandsExecutor,
-//             modules: extensions?.modules,
-//             functionsExecutor: RedisClusterMultiCommand.prototype.functionsExecutor,
-//             functions: extensions?.functions,
-//             scriptsExecutor: RedisClusterMultiCommand.prototype.scriptsExecutor,
-//             scripts: extensions?.scripts
-//         });
-//     }
-//     constructor(executor: RedisClusterMultiExecutor, firstKey?: RedisCommandArgument) {
-//         this.#executor = executor;
-//         this.#firstKey = firstKey;
-//     }
-//     commandsExecutor(command: RedisCommand, args: Array<unknown>): this {
-//         const transformedArguments = command.transformArguments(...args);
-//         this.#firstKey ??= RedisCluster.extractFirstKey(command, args, transformedArguments);
-//         return this.addCommand(undefined, transformedArguments, command.transformReply);
-//     }
-//     addCommand(
-//         firstKey: RedisCommandArgument | undefined,
-//         args: RedisCommandArguments,
-//         transformReply?: RedisCommand['transformReply']
-//     ): this {
-//         this.#firstKey ??= firstKey;
-//         this.#multi.addCommand(args, transformReply);
-//         return this;
-//     }
-//     functionsExecutor(fn: RedisFunction, args: Array<unknown>, name: string): this {
-//         const transformedArguments = this.#multi.addFunction(name, fn, args);
-//         this.#firstKey ??= RedisCluster.extractFirstKey(fn, args, transformedArguments);
-//         return this;
-//     }
-//     scriptsExecutor(script: RedisScript, args: Array<unknown>): this {
-//         const transformedArguments = this.#multi.addScript(script, args);
-//         this.#firstKey ??= RedisCluster.extractFirstKey(script, args, transformedArguments);
-//         return this;
-//     }
-//     async exec(execAsPipeline = false): Promise<Array<RedisCommandRawReply>> {
-//         if (execAsPipeline) {
-//             return this.execAsPipeline();
-//         }
-//         return this.#multi.handleExecReplies(
-//             await this.#executor(this.#multi.queue, this.#firstKey, RedisMultiCommand.generateChainId())
-//         );
-//     }
-//     EXEC = this.exec;
-//     async execAsPipeline(): Promise<Array<RedisCommandRawReply>> {
-//         return this.#multi.transformReplies(
-//             await this.#executor(this.#multi.queue, this.#firstKey)
-//         );
-//     }
-// }
-// attachCommands({
-//     BaseClass: RedisClusterMultiCommand,
-//     commands: COMMANDS,
-//     executor: RedisClusterMultiCommand.prototype.commandsExecutor
-// });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = __importDefault(require("../commands"));
+const multi_command_1 = __importDefault(require("../multi-command"));
+const commander_1 = require("../commander");
+const _1 = __importDefault(require("."));
+class RedisClusterMultiCommand {
+    static _createCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            const redisArgs = command.transformArguments(...args), firstKey = _1.default.extractFirstKey(command, args, redisArgs);
+            return this.addCommand(firstKey, command.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static _createModuleCommand(command, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(command, resp);
+        return function (...args) {
+            const redisArgs = command.transformArguments(...args), firstKey = _1.default.extractFirstKey(command, args, redisArgs);
+            return this.self.addCommand(firstKey, command.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static _createFunctionCommand(name, fn, resp) {
+        const prefix = (0, commander_1.functionArgumentsPrefix)(name, fn), transformReply = (0, commander_1.getTransformReply)(fn, resp);
+        return function (...args) {
+            const fnArgs = fn.transformArguments(...args), redisArgs = prefix.concat(fnArgs), firstKey = _1.default.extractFirstKey(fn, args, fnArgs);
+            redisArgs.preserve = fnArgs.preserve;
+            return this.self.addCommand(firstKey, fn.IS_READ_ONLY, redisArgs, transformReply);
+        };
+    }
+    static _createScriptCommand(script, resp) {
+        const transformReply = (0, commander_1.getTransformReply)(script, resp);
+        return function (...args) {
+            const scriptArgs = script.transformArguments(...args);
+            this._setState(_1.default.extractFirstKey(script, args, scriptArgs), script.IS_READ_ONLY);
+            this._multi.addScript(script, scriptArgs, transformReply);
+            return this;
+        };
+    }
+    static extend(config) {
+        return (0, commander_1.attachConfig)({
+            BaseClass: RedisClusterMultiCommand,
+            commands: commands_1.default,
+            createCommand: RedisClusterMultiCommand._createCommand,
+            createModuleCommand: RedisClusterMultiCommand._createModuleCommand,
+            createFunctionCommand: RedisClusterMultiCommand._createFunctionCommand,
+            createScriptCommand: RedisClusterMultiCommand._createScriptCommand,
+            config
+        });
+    }
+    constructor(cluster, routing) {
+        this._multi = new multi_command_1.default();
+        this._isReadonly = true;
+        this.EXEC = this.exec;
+        this._cluster = cluster;
+        this._firstKey = routing;
+    }
+    _setState(firstKey, isReadonly) {
+        this._firstKey ??= firstKey;
+        this._isReadonly &&= isReadonly;
+    }
+    addCommand(firstKey, isReadonly, args, transformReply) {
+        this._setState(firstKey, isReadonly);
+        this._multi.addCommand(args, transformReply);
+        return this;
+    }
+    async exec(execAsPipeline = false) {
+        if (execAsPipeline)
+            return this.execAsPipeline();
+        return this._multi.transformReplies(await this._cluster.executeMulti(this._firstKey, this._isReadonly, this._multi.queue));
+    }
+    execTyped(execAsPipeline = false) {
+        return this.exec(execAsPipeline);
+    }
+    async execAsPipeline() {
+        if (this._multi.queue.length === 0)
+            return [];
+        return this._multi.transformReplies(await this._cluster.executePipeline(this._firstKey, this._isReadonly, this._multi.queue));
+    }
+    execAsPipelineTyped() {
+        return this.execAsPipeline();
+    }
+}
+exports.default = RedisClusterMultiCommand;

dist/lib/commands/ACL_GETUSER.d.ts

@@ -1,2 +0,1 @@
-/// <reference types="node" />
 import { RedisArgument, TuplesToMapReply, BlobStringReply, ArrayReply, Resp2Reply } from '../RESP/types';
@@ -51,139 +50,35 @@ type AclUser = TuplesToMapReply<[
         readonly 2: (reply: Resp2Reply<AclUser>) => {
-            flags: ((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            })[] & {
+            flags: BlobStringReply[] & {
                 RESP_TYPE: 42;
-                DEFAULT: ((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[];
+                DEFAULT: BlobStringReply[];
                 TYPES: never;
                 /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[]>;
+                FLAG: import("../RESP/types").Flag<BlobStringReply[]>;
             };
-            passwords: ((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            })[] & {
+            passwords: BlobStringReply[] & {
                 RESP_TYPE: 42;
-                DEFAULT: ((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[];
+                DEFAULT: BlobStringReply[];
                 TYPES: never;
                 /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[]>;
+                FLAG: import("../RESP/types").Flag<BlobStringReply[]>;
             };
-            commands: (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            };
-            keys: (((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            })[] & {
+            commands: BlobStringReply;
+            keys: BlobStringReply | (BlobStringReply[] & {
                 RESP_TYPE: 42;
-                DEFAULT: ((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[];
+                DEFAULT: BlobStringReply[];
                 TYPES: never;
                 /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[]>;
-            }) | ((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
+                FLAG: import("../RESP/types").Flag<BlobStringReply[]>;
             });
-            channels: (((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            })[] & {
+            channels: BlobStringReply | (BlobStringReply[] & {
                 RESP_TYPE: 42;
-                DEFAULT: ((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[];
+                DEFAULT: BlobStringReply[];
                 TYPES: never;
                 /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[]>;
-            }) | ((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                /** added in 6.2, changed to BlobStringReply in 7.0 */
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
+                FLAG: import("../RESP/types").Flag<BlobStringReply[]>;
             });
             selectors: {
-                commands: (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                };
-                keys: (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                };
-                channels: (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    /** added in 6.2, changed to BlobStringReply in 7.0 */
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                };
+                commands: BlobStringReply;
+                keys: BlobStringReply;
+                channels: BlobStringReply;
             }[];
@@ -190,0 +85,0 @@ };

dist/lib/commands/ACL_LOG_RESET.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ACL_LOG_1 = require("./ACL_LOG");
+const ACL_LOG_1 = __importDefault(require("./ACL_LOG"));
 exports.default = {
@@ -5,0 +8,0 @@ FIRST_KEY_INDEX: undefined,

dist/lib/commands/ACL_LOG.d.ts

@@ -1,3 +0,2 @@
-/// <reference types="node" />
-import { Resp2Reply } from '../RESP/types';
+import { DoubleReply, Resp2Reply } from '../RESP/types';
 import { ArrayReply, BlobStringReply, NumberReply, TuplesToMapReply } from '../RESP/types';
@@ -27,3 +26,3 @@ export type AclLogReply = ArrayReply<TuplesToMapReply<[
         BlobStringReply<'age-seconds'>,
-        BlobStringReply
+        DoubleReply
     ],
@@ -33,2 +32,17 @@ [
         BlobStringReply
+    ],
+    /** added in 7.0 */
+    [
+        BlobStringReply<'entry-id'>,
+        NumberReply
+    ],
+    /** added in 7.0 */
+    [
+        BlobStringReply<'timestamp-created'>,
+        NumberReply
+    ],
+    /** added in 7.0 */
+    [
+        BlobStringReply<'timestamp-last-updated'>,
+        NumberReply
     ]
@@ -42,1085 +56,13 @@ ]>>;
         readonly 2: (reply: Resp2Reply<AclLogReply>) => {
-            count: number;
-            reason: [(Buffer | "count") & {
-                RESP_TYPE: 36;
-                DEFAULT: "count";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "count">;
-            }, (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            }, (Buffer | "reason") & {
-                RESP_TYPE: 36;
-                DEFAULT: "reason";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "context") & {
-                RESP_TYPE: 36;
-                DEFAULT: "context";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "context">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, ("object" | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: "object";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "username") & {
-                RESP_TYPE: 36;
-                DEFAULT: "username";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "username">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "age-seconds") & {
-                RESP_TYPE: 36;
-                DEFAULT: "age-seconds";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "client-info") & {
-                RESP_TYPE: 36;
-                DEFAULT: "client-info";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }] & {
-                RESP_TYPE: 42;
-                DEFAULT: [(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }];
-                TYPES: never;
-                FLAG: import("../RESP/types").Flag<[(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }]>;
-            };
-            context: [(Buffer | "count") & {
-                RESP_TYPE: 36;
-                DEFAULT: "count";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "count">;
-            }, (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            }, (Buffer | "reason") & {
-                RESP_TYPE: 36;
-                DEFAULT: "reason";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "context") & {
-                RESP_TYPE: 36;
-                DEFAULT: "context";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "context">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, ("object" | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: "object";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "username") & {
-                RESP_TYPE: 36;
-                DEFAULT: "username";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "username">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "age-seconds") & {
-                RESP_TYPE: 36;
-                DEFAULT: "age-seconds";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "client-info") & {
-                RESP_TYPE: 36;
-                DEFAULT: "client-info";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }] & {
-                RESP_TYPE: 42;
-                DEFAULT: [(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }];
-                TYPES: never;
-                FLAG: import("../RESP/types").Flag<[(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }]>;
-            };
-            object: [(Buffer | "count") & {
-                RESP_TYPE: 36;
-                DEFAULT: "count";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "count">;
-            }, (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            }, (Buffer | "reason") & {
-                RESP_TYPE: 36;
-                DEFAULT: "reason";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "context") & {
-                RESP_TYPE: 36;
-                DEFAULT: "context";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "context">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, ("object" | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: "object";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "username") & {
-                RESP_TYPE: 36;
-                DEFAULT: "username";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "username">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "age-seconds") & {
-                RESP_TYPE: 36;
-                DEFAULT: "age-seconds";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "client-info") & {
-                RESP_TYPE: 36;
-                DEFAULT: "client-info";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }] & {
-                RESP_TYPE: 42;
-                DEFAULT: [(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }];
-                TYPES: never;
-                FLAG: import("../RESP/types").Flag<[(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }]>;
-            };
-            username: [(Buffer | "count") & {
-                RESP_TYPE: 36;
-                DEFAULT: "count";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "count">;
-            }, (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            }, (Buffer | "reason") & {
-                RESP_TYPE: 36;
-                DEFAULT: "reason";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "context") & {
-                RESP_TYPE: 36;
-                DEFAULT: "context";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "context">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, ("object" | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: "object";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "username") & {
-                RESP_TYPE: 36;
-                DEFAULT: "username";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "username">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "age-seconds") & {
-                RESP_TYPE: 36;
-                DEFAULT: "age-seconds";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "client-info") & {
-                RESP_TYPE: 36;
-                DEFAULT: "client-info";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }] & {
-                RESP_TYPE: 42;
-                DEFAULT: [(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }];
-                TYPES: never;
-                FLAG: import("../RESP/types").Flag<[(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }]>;
-            };
+            count: NumberReply;
+            reason: BlobStringReply;
+            context: BlobStringReply;
+            object: BlobStringReply;
+            username: BlobStringReply;
             'age-seconds': number;
-            'client-info': [(Buffer | "count") & {
-                RESP_TYPE: 36;
-                DEFAULT: "count";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "count">;
-            }, (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            }, (Buffer | "reason") & {
-                RESP_TYPE: 36;
-                DEFAULT: "reason";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "context") & {
-                RESP_TYPE: 36;
-                DEFAULT: "context";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "context">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, ("object" | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: "object";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "username") & {
-                RESP_TYPE: 36;
-                DEFAULT: "username";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "username">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "age-seconds") & {
-                RESP_TYPE: 36;
-                DEFAULT: "age-seconds";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }, (Buffer | "client-info") & {
-                RESP_TYPE: 36;
-                DEFAULT: "client-info";
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-            }, (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            }] & {
-                RESP_TYPE: 42;
-                DEFAULT: [(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }];
-                TYPES: never;
-                FLAG: import("../RESP/types").Flag<[(Buffer | "count") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "count";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "count">;
-                }, (number | `${number}`) & {
-                    RESP_TYPE: 58;
-                    DEFAULT: number;
-                    TYPES: `${number}`;
-                    FLAG: import("../RESP/types").Flag<number | `${number}`>;
-                }, (Buffer | "reason") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "reason";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "reason">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "context") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "context";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "context">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, ("object" | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "object";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<"object" | Buffer>;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "username") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "username";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "username">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "age-seconds") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "age-seconds";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "age-seconds">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }, (Buffer | "client-info") & {
-                    RESP_TYPE: 36;
-                    DEFAULT: "client-info";
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<Buffer | "client-info">;
-                }, (string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                }]>;
-            };
-        };
+            'client-info': BlobStringReply;
+            'entry-id': NumberReply;
+            'timestamp-created': NumberReply;
+            'timestamp-last-updated': NumberReply;
+        }[];
         readonly 3: () => AclLogReply;
@@ -1127,0 +69,0 @@ };

dist/lib/commands/ACL_LOG.js

@@ -14,13 +14,16 @@ "use strict";
     transformReply: {
-        2: (reply) => ({
-            count: Number(reply[1]),
-            reason: reply[3],
-            context: reply[5],
-            object: reply[7],
-            username: reply[9],
-            'age-seconds': Number(reply[11]),
-            'client-info': reply[13]
-        }),
+        2: (reply) => reply.map(item => ({
+            count: item[1],
+            reason: item[3],
+            context: item[5],
+            object: item[7],
+            username: item[9],
+            'age-seconds': Number(item[11]),
+            'client-info': item[13],
+            'entry-id': item[15],
+            'timestamp-created': item[17],
+            'timestamp-last-updated': item[19]
+        })),
         3: undefined
     }
 };

dist/lib/commands/ACL_WHOAMI.js

@@ -7,5 +7,5 @@ "use strict";
     transformArguments() {
-        return ['ACL', 'USERS'];
+        return ['ACL', 'WHOAMI'];
     },
     transformReply: undefined
 };

dist/lib/commands/BGSAVE.d.ts

 import { SimpleStringReply } from '../RESP/types';
+export interface BgSaveOptions {
+    SCHEDULE?: boolean;
+}
 declare const _default: {
     readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
-    readonly transformArguments: (this: void) => string[];
+    readonly transformArguments: (this: void, options?: BgSaveOptions) => string[];
     readonly transformReply: () => SimpleStringReply;
 };
 export default _default;

dist/lib/commands/BGSAVE.js

@@ -6,6 +6,10 @@ "use strict";
     IS_READ_ONLY: true,
-    transformArguments() {
-        return ['BGSAVE'];
+    transformArguments(options) {
+        const args = ['BGSAVE'];
+        if (options?.SCHEDULE) {
+            args.push('SCHEDULE');
+        }
+        return args;
     },
     transformReply: undefined
 };

dist/lib/commands/BLMPOP.d.ts

@@ -1,2 +0,3 @@
-import { LMPopOptions, ListSide, RedisVariadicArgument } from './generic-transformers';
+import { ListSide, RedisVariadicArgument } from './generic-transformers';
+import { LMPopOptions } from './LMPOP';
 declare const _default: {
@@ -3,0 +4,0 @@ readonly FIRST_KEY_INDEX: 3;

dist/lib/commands/BLMPOP.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const generic_transformers_1 = require("./generic-transformers");
-const LMPOP_1 = require("./LMPOP");
+const LMPOP_1 = __importStar(require("./LMPOP"));
 exports.default = {
@@ -9,5 +31,5 @@ FIRST_KEY_INDEX: 3,
     transformArguments(timeout, keys, side, options) {
-        return (0, generic_transformers_1.transformLMPopArguments)(['BLMPOP', timeout.toString()], keys, side, options);
+        return (0, LMPOP_1.transformLMPopArguments)(['BLMPOP', timeout.toString()], keys, side, options);
     },
     transformReply: LMPOP_1.default.transformReply
 };

dist/lib/commands/BRPOP.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const generic_transformers_1 = require("./generic-transformers");
-const BLPOP_1 = require("./BLPOP");
+const BLPOP_1 = __importDefault(require("./BLPOP"));
 exports.default = {
@@ -6,0 +9,0 @@ FIRST_KEY_INDEX: 1,

dist/lib/commands/BZMPOP.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { SortedSetSide, transformZMPopArguments, ZMPopOptions } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 3;
@@ -5,0 +6,0 @@ // export function transformArguments(

dist/lib/commands/BZPOPMAX.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { pushVariadicArguments, transformDoubleReply, ZMember } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -5,0 +6,0 @@ // export function transformArguments(

dist/lib/commands/BZPOPMIN.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { pushVariadicArguments } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -5,0 +6,0 @@ // export function transformArguments(

dist/lib/commands/CLIENT_CACHING.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, value: boolean) => string[];

dist/lib/commands/CLIENT_CACHING.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(value) {

dist/lib/commands/CLIENT_GETNAME.d.ts

 import { BlobStringReply, NullReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLIENT_GETNAME.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/CLIENT_GETREDIR.d.ts

 import { NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLIENT_GETREDIR.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/CLIENT_ID.d.ts

 import { NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLIENT_ID.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/CLIENT_INFO.d.ts

@@ -55,2 +55,3 @@ import { VerbatimStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -57,0 +58,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLIENT_INFO.js

@@ -5,2 +5,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -7,0 +8,0 @@ transformArguments() {

dist/lib/commands/CLIENT_KILL.d.ts

@@ -34,2 +34,3 @@ import { NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -36,0 +37,0 @@ readonly transformArguments: (this: void, filters: ClientKillFilter | Array<ClientKillFilter>) => string[];

dist/lib/commands/CLIENT_KILL.js

@@ -13,2 +13,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -15,0 +16,0 @@ transformArguments(filters) {

dist/lib/commands/CLIENT_LIST.d.ts

@@ -13,2 +13,3 @@ import { RedisArgument, VerbatimStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -15,0 +16,0 @@ readonly transformArguments: (this: void, filter?: ListFilter) => RedisArgument[];

dist/lib/commands/CLIENT_LIST.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const generic_transformers_1 = require("./generic-transformers");
-const CLIENT_INFO_1 = require("./CLIENT_INFO");
+const CLIENT_INFO_1 = __importDefault(require("./CLIENT_INFO"));
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -7,0 +11,0 @@ transformArguments(filter) {

dist/lib/commands/CLIENT_NO-EVICT.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, value: boolean) => string[];

dist/lib/commands/CLIENT_NO-EVICT.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(value) {

dist/lib/commands/CLIENT_PAUSE.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, timeout: number, mode?: 'WRITE' | 'ALL') => string[];

dist/lib/commands/CLIENT_PAUSE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(timeout, mode) {

dist/lib/commands/CLIENT_SETNAME.d.ts

 import { RedisArgument, SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, name: RedisArgument) => RedisArgument[];

dist/lib/commands/CLIENT_SETNAME.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(name) {

dist/lib/commands/CLIENT_TRACKING.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// interface CommonOptions {
-//     REDIRECT?: number;
-//     NOLOOP?: boolean;
-// }
-// interface BroadcastOptions {
-//     BCAST?: boolean;
-//     PREFIX?: RedisCommandArgument | Array<RedisCommandArgument>;
-// }
-// interface OptInOptions {
-//     OPTIN?: boolean;
-// }
-// interface OptOutOptions {
-//     OPTOUT?: boolean;
-// }
-// type ClientTrackingOptions = CommonOptions & (
-//     BroadcastOptions |
-//     OptInOptions |
-//     OptOutOptions
-// );
-// export function transformArguments<M extends boolean>(
-//     mode: M,
-//     options?: M extends true ? ClientTrackingOptions : undefined
-// ): RedisCommandArguments {
-//     const args: RedisCommandArguments = [
-//         'CLIENT',
-//         'TRACKING',
-//         mode ? 'ON' : 'OFF'
-//     ];
-//     if (mode) {
-//         if (options?.REDIRECT) {
-//             args.push(
-//                 'REDIRECT',
-//                 options.REDIRECT.toString()
-//             );
-//         }
-//         if (isBroadcast(options)) {
-//             args.push('BCAST');
-//             if (options?.PREFIX) {
-//                 if (Array.isArray(options.PREFIX)) {
-//                     for (const prefix of options.PREFIX) {
-//                         args.push('PREFIX', prefix);
-//                     }
-//                 } else {
-//                     args.push('PREFIX', options.PREFIX);
-//                 }
-//             }
-//         } else if (isOptIn(options)) {
-//             args.push('OPTIN');
-//         } else if (isOptOut(options)) {
-//             args.push('OPTOUT');
-//         }
-//         if (options?.NOLOOP) {
-//             args.push('NOLOOP');
-//         }
-//     }
-//     return args;
-// }
-// function isBroadcast(options?: ClientTrackingOptions): options is BroadcastOptions {
-//     return (options as BroadcastOptions)?.BCAST === true;
-// }
-// function isOptIn(options?: ClientTrackingOptions): options is OptInOptions {
-//     return (options as OptInOptions)?.OPTIN === true;
-// }
-// function isOptOut(options?: ClientTrackingOptions): options is OptOutOptions {
-//     return (options as OptOutOptions)?.OPTOUT === true;
-// }
-// export declare function transformReply(): 'OK' | Buffer;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(mode, options) {
+        const args = [
+            'CLIENT',
+            'TRACKING',
+            mode ? 'ON' : 'OFF'
+        ];
+        if (mode) {
+            if (options?.REDIRECT) {
+                args.push('REDIRECT', options.REDIRECT.toString());
+            }
+            if (isBroadcast(options)) {
+                args.push('BCAST');
+                if (options?.PREFIX) {
+                    if (Array.isArray(options.PREFIX)) {
+                        for (const prefix of options.PREFIX) {
+                            args.push('PREFIX', prefix);
+                        }
+                    }
+                    else {
+                        args.push('PREFIX', options.PREFIX);
+                    }
+                }
+            }
+            else if (isOptIn(options)) {
+                args.push('OPTIN');
+            }
+            else if (isOptOut(options)) {
+                args.push('OPTOUT');
+            }
+            if (options?.NOLOOP) {
+                args.push('NOLOOP');
+            }
+        }
+        return args;
+    },
+    transformReply: undefined
+};
+function isBroadcast(options) {
+    return options?.BCAST === true;
+}
+function isOptIn(options) {
+    return options?.OPTIN === true;
+}
+function isOptOut(options) {
+    return options?.OPTOUT === true;
+}

dist/lib/commands/CLIENT_TRACKINGINFO.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// export function transformArguments(): RedisCommandArguments {
-//     return ['CLIENT', 'TRACKINGINFO'];
-// }
-// type RawReply = [
-//     'flags',
-//     Array<string>,
-//     'redirect',
-//     number,
-//     'prefixes',
-//     Array<string>
-// ];
-// interface Reply {
-//     flags: Set<string>;
-//     redirect: number;
-//     prefixes: Array<string>;
-// }
-// export function transformReply(reply: RawReply): Reply {
-//     return {
-//         flags: new Set(reply[1]),
-//         redirect: reply[3],
-//         prefixes: reply[5]
-//     };
-// }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['CLIENT', 'TRACKINGINFO'];
+    },
+    transformReply: {
+        2: (reply) => ({
+            flags: reply[1],
+            redirect: reply[3],
+            prefixes: reply[5]
+        }),
+        3: undefined
+    }
+};

dist/lib/commands/CLIENT_UNPAUSE.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLIENT_UNPAUSE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/CLUSTER_ADDSLOTS.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, slots: number | Array<number>) => import("../RESP/types").CommandArguments;

dist/lib/commands/CLUSTER_ADDSLOTS.js

@@ -5,2 +5,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -7,0 +8,0 @@ transformArguments(slots) {

dist/lib/commands/CLUSTER_ADDSLOTSRANGE.d.ts

 import { SimpleStringReply } from '../RESP/types';
 import { SlotRange } from './generic-transformers';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -5,0 +6,0 @@ readonly transformArguments: (this: void, ranges: SlotRange | Array<SlotRange>) => import("../RESP/types").CommandArguments;

dist/lib/commands/CLUSTER_ADDSLOTSRANGE.js

@@ -5,2 +5,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -7,0 +8,0 @@ transformArguments(ranges) {

dist/lib/commands/CLUSTER_BUMPEPOCH.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLUSTER_BUMPEPOCH.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/CLUSTER_COUNT-FAILURE-REPORTS.d.ts

 import { RedisArgument, NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, nodeId: RedisArgument) => RedisArgument[];

dist/lib/commands/CLUSTER_COUNT-FAILURE-REPORTS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(nodeId) {

dist/lib/commands/CLUSTER_COUNTKEYSINSLOT.d.ts

 import { NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, slot: number) => string[];

dist/lib/commands/CLUSTER_COUNTKEYSINSLOT.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
     transformArguments(slot) {
-        return ['CLUSTER', 'COUNT-FAILURE-REPORTS', slot.toString()];
+        return ['CLUSTER', 'COUNTKEYSINSLOT', slot.toString()];
     },
     transformReply: undefined
 };

dist/lib/commands/CLUSTER_DELSLOTS.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, slots: number | Array<number>) => import("../RESP/types").CommandArguments;

dist/lib/commands/CLUSTER_DELSLOTS.js

@@ -5,2 +5,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -7,0 +8,0 @@ transformArguments(slots) {

dist/lib/commands/CLUSTER_DELSLOTSRANGE.d.ts

 import { SimpleStringReply } from '../RESP/types';
 import { SlotRange } from './generic-transformers';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -5,0 +6,0 @@ readonly transformArguments: (this: void, ranges: SlotRange | Array<SlotRange>) => import("../RESP/types").CommandArguments;

dist/lib/commands/CLUSTER_DELSLOTSRANGE.js

@@ -5,2 +5,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -7,0 +8,0 @@ transformArguments(ranges) {

dist/lib/commands/CLUSTER_FAILOVER.d.ts

@@ -6,8 +6,12 @@ import { SimpleStringReply } from '../RESP/types';
 };
-export type FailoverModes = typeof FAILOVER_MODES[keyof typeof FAILOVER_MODES];
+export type FailoverMode = typeof FAILOVER_MODES[keyof typeof FAILOVER_MODES];
+export interface ClusterFailoverOptions {
+    mode?: FailoverMode;
+}
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
-    readonly transformArguments: (this: void, mode?: FailoverModes) => string[];
+    readonly transformArguments: (this: void, options?: ClusterFailoverOptions) => string[];
     readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/CLUSTER_FAILOVER.js

@@ -9,7 +9,8 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
-    transformArguments(mode) {
+    transformArguments(options) {
         const args = ['CLUSTER', 'FAILOVER'];
-        if (mode) {
-            args.push(mode);
+        if (options?.mode) {
+            args.push(options.mode);
         }
@@ -16,0 +17,0 @@ return args;

dist/lib/commands/CLUSTER_FLUSHSLOTS.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLUSTER_FLUSHSLOTS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/CLUSTER_FORGET.d.ts

 import { RedisArgument, SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, nodeId: RedisArgument) => RedisArgument[];

dist/lib/commands/CLUSTER_FORGET.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(nodeId) {

dist/lib/commands/CLUSTER_GETKEYSINSLOT.d.ts

 import { ArrayReply, BlobStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, slot: number, count: number) => string[];

dist/lib/commands/CLUSTER_GETKEYSINSLOT.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(slot, count) {

dist/lib/commands/CLUSTER_KEYSLOT.d.ts

 import { NumberReply, RedisArgument } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void, key: RedisArgument) => RedisArgument[];
@@ -4,0 +6,0 @@ readonly transformReply: () => NumberReply;

dist/lib/commands/CLUSTER_KEYSLOT.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments(key) {
@@ -5,0 +7,0 @@ return ['CLUSTER', 'KEYSLOT', key];

dist/lib/commands/CLUSTER_LINKS.d.ts

@@ -1,25 +0,44 @@
-export declare function transformArguments(): Array<string>;
-type ClusterLinksRawReply = Array<[
-    'direction',
-    string,
-    'node',
-    string,
-    'createTime',
-    number,
-    'events',
-    string,
-    'send-buffer-allocated',
-    number,
-    'send-buffer-used',
-    number
-]>;
-type ClusterLinksReply = Array<{
-    direction: string;
-    node: string;
-    createTime: number;
-    events: string;
-    sendBufferAllocated: number;
-    sendBufferUsed: number;
-}>;
-export declare function transformReply(reply: ClusterLinksRawReply): ClusterLinksReply;
-export {};
+import { ArrayReply, TuplesToMapReply, BlobStringReply, NumberReply, Resp2Reply } from '../RESP/types';
+type ClusterLinksReply = ArrayReply<TuplesToMapReply<[
+    [
+        BlobStringReply<'direction'>,
+        BlobStringReply
+    ],
+    [
+        BlobStringReply<'node'>,
+        BlobStringReply
+    ],
+    [
+        BlobStringReply<'create-time'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'events'>,
+        BlobStringReply
+    ],
+    [
+        BlobStringReply<'send-buffer-allocated'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'send-buffer-used'>,
+        NumberReply
+    ]
+]>>;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: {
+        readonly 2: (reply: Resp2Reply<ClusterLinksReply>) => {
+            direction: BlobStringReply;
+            node: BlobStringReply;
+            'create-time': NumberReply;
+            events: BlobStringReply;
+            'send-buffer-allocated': NumberReply;
+            'send-buffer-used': NumberReply;
+        }[];
+        readonly 3: () => ClusterLinksReply;
+    };
+};
+export default _default;

dist/lib/commands/CLUSTER_LINKS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReply = exports.transformArguments = void 0;
-function transformArguments() {
-    return ['CLUSTER', 'LINKS'];
-}
-exports.transformArguments = transformArguments;
-function transformReply(reply) {
-    return reply.map(peerLink => ({
-        direction: peerLink[1],
-        node: peerLink[3],
-        createTime: Number(peerLink[5]),
-        events: peerLink[7],
-        sendBufferAllocated: Number(peerLink[9]),
-        sendBufferUsed: Number(peerLink[11])
-    }));
-}
-exports.transformReply = transformReply;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['CLUSTER', 'LINKS'];
+    },
+    transformReply: {
+        2: (reply) => reply.map(link => ({
+            direction: link[1],
+            node: link[3],
+            'create-time': link[5],
+            events: link[7],
+            'send-buffer-allocated': link[9],
+            'send-buffer-used': link[11]
+        })),
+        3: undefined
+    }
+};

dist/lib/commands/CLUSTER_MEET.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void, host: string, port: number) => string[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/CLUSTER_MEET.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments(host, port) {
@@ -5,0 +7,0 @@ return ['CLUSTER', 'MEET', host, port.toString()];

dist/lib/commands/CLUSTER_MYID.d.ts

@@ -1,3 +0,5 @@
-import { BlobStringReply } from "../RESP/types";
+import { BlobStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void) => string[];
@@ -4,0 +6,0 @@ readonly transformReply: () => BlobStringReply;

dist/lib/commands/CLUSTER_MYID.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments() {
@@ -5,0 +7,0 @@ return ['CLUSTER', 'MYID'];

dist/lib/commands/CLUSTER_NODES.js

@@ -12,3 +12,3 @@ "use strict";
     RedisClusterNodeLinkStates["DISCONNECTED"] = "disconnected";
-})(RedisClusterNodeLinkStates = exports.RedisClusterNodeLinkStates || (exports.RedisClusterNodeLinkStates = {}));
+})(RedisClusterNodeLinkStates || (exports.RedisClusterNodeLinkStates = RedisClusterNodeLinkStates = {}));
 function transformReply(reply) {
@@ -15,0 +15,0 @@ const lines = reply.split('\n');

dist/lib/commands/CLUSTER_REPLICATE.d.ts

 import { RedisArgument, SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void, nodeId: RedisArgument) => RedisArgument[];
@@ -4,0 +6,0 @@ readonly transformReply: () => SimpleStringReply;

dist/lib/commands/CLUSTER_REPLICATE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments(nodeId) {
@@ -5,0 +7,0 @@ return ['CLUSTER', 'REPLICATE', nodeId];

dist/lib/commands/CLUSTER_RESET.d.ts

@@ -1,2 +0,11 @@
-export declare function transformArguments(mode?: 'HARD' | 'SOFT'): Array<string>;
-export declare function transformReply(): string;
+import { SimpleStringReply } from '../RESP/types';
+export interface ClusterResetOptions {
+    mode?: 'HARD' | 'SOFT';
+}
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, options?: ClusterResetOptions) => string[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

dist/lib/commands/CLUSTER_RESET.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments(mode) {
-    const args = ['CLUSTER', 'RESET'];
-    if (mode) {
-        args.push(mode);
-    }
-    return args;
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(options) {
+        const args = ['CLUSTER', 'RESET'];
+        if (options?.mode) {
+            args.push(options.mode);
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/CLUSTER_SAVECONFIG.d.ts

@@ -1,2 +0,8 @@
-export declare function transformArguments(): Array<string>;
-export declare function transformReply(): 'OK';
+import { SimpleStringReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

dist/lib/commands/CLUSTER_SAVECONFIG.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments() {
-    return ['CLUSTER', 'SAVECONFIG'];
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['CLUSTER', 'SAVECONFIG'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/CLUSTER_SET-CONFIG-EPOCH.d.ts

@@ -1,2 +0,8 @@
-export declare function transformArguments(configEpoch: number): Array<string>;
-export declare function transformReply(): 'OK';
+import { SimpleStringReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, configEpoch: number) => string[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

dist/lib/commands/CLUSTER_SET-CONFIG-EPOCH.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments(configEpoch) {
-    return ['CLUSTER', 'SET-CONFIG-EPOCH', configEpoch.toString()];
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(configEpoch) {
+        return ['CLUSTER', 'SET-CONFIG-EPOCH', configEpoch.toString()];
+    },
+    transformReply: undefined
+};

dist/lib/commands/CLUSTER_SETSLOT.d.ts

@@ -1,8 +0,15 @@
-export declare enum ClusterSlotStates {
-    IMPORTING = "IMPORTING",
-    MIGRATING = "MIGRATING",
-    STABLE = "STABLE",
-    NODE = "NODE"
-}
-export declare function transformArguments(slot: number, state: ClusterSlotStates, nodeId?: string): Array<string>;
-export declare function transformReply(): 'OK';
+import { RedisArgument, SimpleStringReply } from '../RESP/types';
+export declare const CLUSTER_SLOT_STATES: {
+    readonly IMPORTING: "IMPORTING";
+    readonly MIGRATING: "MIGRATING";
+    readonly STABLE: "STABLE";
+    readonly NODE: "NODE";
+};
+export type ClusterSlotState = typeof CLUSTER_SLOT_STATES[keyof typeof CLUSTER_SLOT_STATES];
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, slot: number, state: ClusterSlotState, nodeId?: RedisArgument) => RedisArgument[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

dist/lib/commands/CLUSTER_SETSLOT.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.ClusterSlotStates = void 0;
-var ClusterSlotStates;
-(function (ClusterSlotStates) {
-    ClusterSlotStates["IMPORTING"] = "IMPORTING";
-    ClusterSlotStates["MIGRATING"] = "MIGRATING";
-    ClusterSlotStates["STABLE"] = "STABLE";
-    ClusterSlotStates["NODE"] = "NODE";
-})(ClusterSlotStates = exports.ClusterSlotStates || (exports.ClusterSlotStates = {}));
-function transformArguments(slot, state, nodeId) {
-    const args = ['CLUSTER', 'SETSLOT', slot.toString(), state];
-    if (nodeId) {
-        args.push(nodeId);
-    }
-    return args;
-}
-exports.transformArguments = transformArguments;
+exports.CLUSTER_SLOT_STATES = void 0;
+exports.CLUSTER_SLOT_STATES = {
+    IMPORTING: 'IMPORTING',
+    MIGRATING: 'MIGRATING',
+    STABLE: 'STABLE',
+    NODE: 'NODE'
+};
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(slot, state, nodeId) {
+        const args = ['CLUSTER', 'SETSLOT', slot.toString(), state];
+        if (nodeId) {
+            args.push(nodeId);
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/CLUSTER_SLOTS.d.ts

@@ -15,2 +15,3 @@ import { NumberReply, ArrayReply, BlobStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -17,0 +18,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/CLUSTER_SLOTS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/COMMAND_COUNT.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// export const IS_READ_ONLY = true;
-// export function transformArguments(): RedisCommandArguments {
-//     return ['COMMAND', 'COUNT'];
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['COMMAND', 'COUNT'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/COMMAND_GETKEYS.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const IS_READ_ONLY = true;
-// export function transformArguments(args: Array<RedisCommandArgument>): RedisCommandArguments {
-//     return ['COMMAND', 'GETKEYS', ...args];
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(args) {
+        return ['COMMAND', 'GETKEYS', ...args];
+    },
+    transformReply: undefined
+};

dist/lib/commands/COMMAND_GETKEYSANDFLAGS.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const IS_READ_ONLY = true;
@@ -4,0 +5,0 @@ // export function transformArguments(args: Array<RedisCommandArgument>): RedisCommandArguments {

dist/lib/commands/COMMAND_INFO.js

 "use strict";
 // import { RedisCommandArguments } from '.';
 // import { CommandRawReply, CommandReply, transformCommandReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const IS_READ_ONLY = true;
@@ -5,0 +6,0 @@ // export function transformArguments(commands: Array<string>): RedisCommandArguments {

dist/lib/commands/COMMAND_LIST.js

 "use strict";
 // import { RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const IS_READ_ONLY = true;
@@ -4,0 +5,0 @@ // export enum FilterBy {

dist/lib/commands/COMMAND.js

 "use strict";
 // import { RedisCommandArguments } from '.';
 // import { CommandRawReply, CommandReply, transformCommandReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const IS_READ_ONLY = true;
@@ -5,0 +6,0 @@ // export function transformArguments(): RedisCommandArguments {

dist/lib/commands/CONFIG_GET.d.ts

@@ -1,8 +0,12 @@
-import { RedisArgument } from '../RESP/types';
-import { transformTuplesReply } from './generic-transformers';
+import { MapReply, BlobStringReply } from '../RESP/types';
+import { RedisVariadicArgument, transformTuplesReply } from './generic-transformers';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
-    readonly transformArguments: (this: void, parameter: RedisArgument) => RedisArgument[];
-    readonly transformReply: typeof transformTuplesReply;
+    readonly transformArguments: (this: void, parameters: RedisVariadicArgument) => import("../RESP/types").CommandArguments;
+    readonly transformReply: {
+        readonly 2: typeof transformTuplesReply;
+        readonly 3: () => MapReply<BlobStringReply, BlobStringReply>;
+    };
 };
 export default _default;

dist/lib/commands/CONFIG_GET.js

@@ -5,7 +5,11 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
-    transformArguments(parameter) {
-        return ['CONFIG', 'GET', parameter];
+    transformArguments(parameters) {
+        return (0, generic_transformers_1.pushVariadicArguments)(['CONFIG', 'GET'], parameters);
     },
-    transformReply: generic_transformers_1.transformTuplesReply
+    transformReply: {
+        2: generic_transformers_1.transformTuplesReply,
+        3: undefined
+    }
 };

dist/lib/commands/CONFIG_RESETSTAT.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void) => string[];
@@ -4,0 +6,0 @@ readonly transformReply: () => SimpleStringReply;

dist/lib/commands/CONFIG_RESETSTAT.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments() {
@@ -5,0 +7,0 @@ return ['CONFIG', 'RESETSTAT'];

dist/lib/commands/CONFIG_REWRITE.d.ts

 import { SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void) => string[];
@@ -4,0 +6,0 @@ readonly transformReply: () => SimpleStringReply;

dist/lib/commands/CONFIG_REWRITE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments() {
@@ -5,0 +7,0 @@ return ['CONFIG', 'REWRITE'];

dist/lib/commands/CONFIG_SET.d.ts

@@ -5,2 +5,4 @@ import { SimpleStringReply, RedisArgument } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
     readonly transformArguments: (this: void, ...[parameterOrConfig, value]: SingleParameter | MultipleParameters) => RedisArgument[];
@@ -7,0 +9,0 @@ readonly transformReply: () => SimpleStringReply;

dist/lib/commands/CONFIG_SET.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
     transformArguments(...[parameterOrConfig, value]) {
         const args = ['CONFIG', 'SET'];
-        if (typeof parameterOrConfig === 'string' || Buffer.isBuffer(parameterOrConfig)) {
+        if (typeof parameterOrConfig === 'string' || parameterOrConfig instanceof Buffer) {
             args.push(parameterOrConfig, value);
@@ -8,0 +10,0 @@ }

dist/lib/commands/COPY.d.ts

@@ -8,2 +8,3 @@ import { RedisArgument, NumberReply } from '../RESP/types';
     readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
     readonly transformArguments: (this: void, source: RedisArgument, destination: RedisArgument, options?: CopyCommandOptions) => RedisArgument[];
@@ -10,0 +11,0 @@ readonly transformReply: () => NumberReply;

dist/lib/commands/COPY.js

@@ -5,2 +5,3 @@ "use strict";
     FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
     transformArguments(source, destination, options) {
@@ -7,0 +8,0 @@ const args = ['COPY', source, destination];

dist/lib/commands/DBSIZE.d.ts

 import { NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/DBSIZE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/DECRBY.js

@@ -6,5 +6,5 @@ "use strict";
     transformArguments(key, decrement) {
-        return ['DECR', key, decrement.toString()];
+        return ['DECRBY', key, decrement.toString()];
     },
     transformReply: undefined
 };

dist/lib/commands/DEL.d.ts

@@ -5,2 +5,3 @@ import { NumberReply } from '../RESP/types';
     readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
     readonly transformArguments: (this: void, keys: RedisVariadicArgument) => import("../RESP/types").CommandArguments;
@@ -7,0 +8,0 @@ readonly transformReply: () => NumberReply;

dist/lib/commands/DEL.js

@@ -6,2 +6,3 @@ "use strict";
     FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
     transformArguments(keys) {
@@ -8,0 +9,0 @@ return (0, generic_transformers_1.pushVariadicArguments)(['DEL'], keys);

dist/lib/commands/ECHO.d.ts

 import { RedisArgument, BlobStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, message: RedisArgument) => RedisArgument[];

dist/lib/commands/ECHO.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(message) {

dist/lib/commands/EVAL_RO.d.ts

@@ -1,4 +0,7 @@
-import { evalFirstKeyIndex, EvalOptions } from './generic-transformers';
-export declare const FIRST_KEY_INDEX: typeof evalFirstKeyIndex;
-export declare const IS_READ_ONLY = true;
-export declare function transformArguments(script: string, options?: EvalOptions): Array<string>;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: (this: void, _: any, options?: import("./EVAL").EvalOptions | undefined) => import("../RESP/types").RedisArgument | undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (script: import("../RESP/types").RedisArgument, options?: import("./EVAL").EvalOptions | undefined) => import("../RESP/types").RedisArgument[];
+    readonly transformReply: () => import("../RESP/types").ReplyUnion;
+};
+export default _default;

dist/lib/commands/EVAL_RO.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("./generic-transformers");
-exports.FIRST_KEY_INDEX = generic_transformers_1.evalFirstKeyIndex;
-exports.IS_READ_ONLY = true;
-function transformArguments(script, options) {
-    return (0, generic_transformers_1.pushEvalArguments)(['EVAL_RO', script], options);
-}
-exports.transformArguments = transformArguments;
+const EVAL_1 = __importStar(require("./EVAL"));
+exports.default = {
+    FIRST_KEY_INDEX: EVAL_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: true,
+    transformArguments: EVAL_1.transformEvalArguments.bind(undefined, 'EVAL_RO'),
+    transformReply: EVAL_1.default.transformReply
+};

dist/lib/commands/EVAL.d.ts

@@ -1,3 +0,13 @@
-import { evalFirstKeyIndex, EvalOptions } from './generic-transformers';
-export declare const FIRST_KEY_INDEX: typeof evalFirstKeyIndex;
-export declare function transformArguments(script: string, options?: EvalOptions): Array<string>;
+import { RedisArgument, ReplyUnion } from '../RESP/types';
+export interface EvalOptions {
+    keys?: Array<RedisArgument>;
+    arguments?: Array<RedisArgument>;
+}
+export declare function transformEvalArguments(command: RedisArgument, script: RedisArgument, options?: EvalOptions): RedisArgument[];
+declare const _default: {
+    readonly FIRST_KEY_INDEX: (this: void, _: any, options?: EvalOptions) => RedisArgument | undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (script: RedisArgument, options?: EvalOptions | undefined) => RedisArgument[];
+    readonly transformReply: () => ReplyUnion;
+};
+export default _default;

dist/lib/commands/EVAL.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("./generic-transformers");
-exports.FIRST_KEY_INDEX = generic_transformers_1.evalFirstKeyIndex;
-function transformArguments(script, options) {
-    return (0, generic_transformers_1.pushEvalArguments)(['EVAL', script], options);
+exports.transformEvalArguments = void 0;
+function transformEvalArguments(command, script, options) {
+    const args = [command, script];
+    if (options?.keys) {
+        args.push(options.keys.length.toString(), ...options.keys);
+    }
+    else {
+        args.push('0');
+    }
+    if (options?.arguments) {
+        args.push(...options.arguments);
+    }
+    return args;
 }
-exports.transformArguments = transformArguments;
+exports.transformEvalArguments = transformEvalArguments;
+exports.default = {
+    FIRST_KEY_INDEX: (_, options) => options?.keys?.[0],
+    IS_READ_ONLY: false,
+    transformArguments: transformEvalArguments.bind(undefined, 'EVAL'),
+    transformReply: undefined
+};

dist/lib/commands/EVALSHA_RO.d.ts

@@ -1,4 +0,7 @@
-import { evalFirstKeyIndex, EvalOptions } from './generic-transformers';
-export declare const FIRST_KEY_INDEX: typeof evalFirstKeyIndex;
-export declare const IS_READ_ONLY = true;
-export declare function transformArguments(sha1: string, options?: EvalOptions): Array<string>;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: (this: void, _: any, options?: import("./EVAL").EvalOptions | undefined) => import("../RESP/types").RedisArgument | undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (script: import("../RESP/types").RedisArgument, options?: import("./EVAL").EvalOptions | undefined) => import("../RESP/types").RedisArgument[];
+    readonly transformReply: () => import("../RESP/types").ReplyUnion;
+};
+export default _default;

dist/lib/commands/EVALSHA_RO.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("./generic-transformers");
-exports.FIRST_KEY_INDEX = generic_transformers_1.evalFirstKeyIndex;
-exports.IS_READ_ONLY = true;
-function transformArguments(sha1, options) {
-    return (0, generic_transformers_1.pushEvalArguments)(['EVALSHA_RO', sha1], options);
-}
-exports.transformArguments = transformArguments;
+const EVAL_1 = __importStar(require("./EVAL"));
+exports.default = {
+    FIRST_KEY_INDEX: EVAL_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: true,
+    transformArguments: EVAL_1.transformEvalArguments.bind(undefined, 'EVALSHA_RO'),
+    transformReply: EVAL_1.default.transformReply
+};

dist/lib/commands/EVALSHA.d.ts

@@ -1,3 +0,7 @@
-import { evalFirstKeyIndex, EvalOptions } from './generic-transformers';
-export declare const FIRST_KEY_INDEX: typeof evalFirstKeyIndex;
-export declare function transformArguments(sha1: string, options?: EvalOptions): Array<string>;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: (this: void, _: any, options?: import("./EVAL").EvalOptions | undefined) => import("../RESP/types").RedisArgument | undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (script: import("../RESP/types").RedisArgument, options?: import("./EVAL").EvalOptions | undefined) => import("../RESP/types").RedisArgument[];
+    readonly transformReply: () => import("../RESP/types").ReplyUnion;
+};
+export default _default;

dist/lib/commands/EVALSHA.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("./generic-transformers");
-exports.FIRST_KEY_INDEX = generic_transformers_1.evalFirstKeyIndex;
-function transformArguments(sha1, options) {
-    return (0, generic_transformers_1.pushEvalArguments)(['EVALSHA', sha1], options);
-}
-exports.transformArguments = transformArguments;
+const EVAL_1 = __importStar(require("./EVAL"));
+exports.default = {
+    FIRST_KEY_INDEX: EVAL_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: false,
+    transformArguments: EVAL_1.transformEvalArguments.bind(undefined, 'EVALSHA'),
+    transformReply: EVAL_1.default.transformReply
+};

dist/lib/commands/EXPIREAT.js

@@ -8,3 +8,3 @@ "use strict";
     transformArguments(key, timestamp, mode) {
-        const args = ['EXPIRE', key, (0, generic_transformers_1.transformEXAT)(timestamp)];
+        const args = ['EXPIREAT', key, (0, generic_transformers_1.transformEXAT)(timestamp)];
         if (mode) {
@@ -11,0 +11,0 @@ args.push(mode);

dist/lib/commands/FCALL_RO.d.ts

@@ -1,4 +0,8 @@
-import { evalFirstKeyIndex, EvalOptions } from './generic-transformers';
-export declare const FIRST_KEY_INDEX: typeof evalFirstKeyIndex;
-export declare const IS_READ_ONLY = true;
-export declare function transformArguments(fn: string, options?: EvalOptions): Array<string>;
+import { EvalOptions } from './EVAL';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: (this: void, _: any, options?: EvalOptions | undefined) => import("../RESP/types").RedisArgument | undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (script: import("../RESP/types").RedisArgument, options?: EvalOptions | undefined) => import("../RESP/types").RedisArgument[];
+    readonly transformReply: () => import("../RESP/types").ReplyUnion;
+};
+export default _default;

dist/lib/commands/FCALL_RO.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("./generic-transformers");
-exports.FIRST_KEY_INDEX = generic_transformers_1.evalFirstKeyIndex;
-exports.IS_READ_ONLY = true;
-function transformArguments(fn, options) {
-    return (0, generic_transformers_1.pushEvalArguments)(['FCALL_RO', fn], options);
-}
-exports.transformArguments = transformArguments;
+const EVAL_1 = __importStar(require("./EVAL"));
+exports.default = {
+    FIRST_KEY_INDEX: EVAL_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: false,
+    transformArguments: EVAL_1.transformEvalArguments.bind(undefined, 'FCALL_RO'),
+    transformReply: EVAL_1.default.transformReply
+};

dist/lib/commands/FCALL.d.ts

@@ -1,3 +0,8 @@
-import { evalFirstKeyIndex, EvalOptions } from './generic-transformers';
-export declare const FIRST_KEY_INDEX: typeof evalFirstKeyIndex;
-export declare function transformArguments(fn: string, options?: EvalOptions): Array<string>;
+import { EvalOptions } from './EVAL';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: (this: void, _: any, options?: EvalOptions | undefined) => import("../RESP/types").RedisArgument | undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (script: import("../RESP/types").RedisArgument, options?: EvalOptions | undefined) => import("../RESP/types").RedisArgument[];
+    readonly transformReply: () => import("../RESP/types").ReplyUnion;
+};
+export default _default;

dist/lib/commands/FCALL.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.FIRST_KEY_INDEX = void 0;
-const generic_transformers_1 = require("./generic-transformers");
-exports.FIRST_KEY_INDEX = generic_transformers_1.evalFirstKeyIndex;
-function transformArguments(fn, options) {
-    return (0, generic_transformers_1.pushEvalArguments)(['FCALL', fn], options);
-}
-exports.transformArguments = transformArguments;
+const EVAL_1 = __importStar(require("./EVAL"));
+exports.default = {
+    FIRST_KEY_INDEX: EVAL_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: false,
+    transformArguments: EVAL_1.transformEvalArguments.bind(undefined, 'FCALL'),
+    transformReply: EVAL_1.default.transformReply
+};

dist/lib/commands/FLUSHALL.d.ts

@@ -6,7 +6,9 @@ import { SimpleStringReply } from '../RESP/types';
 };
-export type RedisFlushModes = typeof REDIS_FLUSH_MODES[keyof typeof REDIS_FLUSH_MODES];
+export type RedisFlushMode = typeof REDIS_FLUSH_MODES[keyof typeof REDIS_FLUSH_MODES];
 declare const _default: {
-    readonly transformArguments: (this: void, mode?: RedisFlushModes) => string[];
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, mode?: RedisFlushMode) => string[];
     readonly transformReply: () => SimpleStringReply;
 };
 export default _default;

dist/lib/commands/FLUSHALL.js

@@ -9,2 +9,4 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
     transformArguments(mode) {
@@ -11,0 +13,0 @@ const args = ['FLUSHALL'];

dist/lib/commands/FLUSHDB.d.ts

 import { SimpleStringReply } from '../RESP/types';
-import { RedisFlushModes } from './FLUSHALL';
+import { RedisFlushMode } from './FLUSHALL';
 declare const _default: {
-    readonly transformArguments: (this: void, mode?: RedisFlushModes) => string[];
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, mode?: RedisFlushMode) => string[];
     readonly transformReply: () => SimpleStringReply;
 };
 export default _default;

dist/lib/commands/FLUSHDB.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
     transformArguments(mode) {
@@ -5,0 +7,0 @@ const args = ['FLUSHDB'];

dist/lib/commands/FUNCTION_DELETE.d.ts

 import { RedisArgument, SimpleStringReply } from '../RESP/types';
 declare const _default: {
     readonly FIRST_KEY_INDEX: undefined;
-    readonly IS_READ_ONLY: true;
+    readonly IS_READ_ONLY: false;
     readonly transformArguments: (this: void, library: RedisArgument) => RedisArgument[];
@@ -6,0 +6,0 @@ readonly transformReply: () => SimpleStringReply;

dist/lib/commands/FUNCTION_DELETE.js

@@ -5,3 +5,3 @@ "use strict";
     FIRST_KEY_INDEX: undefined,
-    IS_READ_ONLY: true,
+    IS_READ_ONLY: false,
     transformArguments(library) {
@@ -8,0 +8,0 @@ return ['FUNCTION', 'DELETE', library];

dist/lib/commands/FUNCTION_FLUSH.d.ts

 import { SimpleStringReply } from '../RESP/types';
-import { RedisFlushModes } from './FLUSHALL';
+import { RedisFlushMode } from './FLUSHALL';
 declare const _default: {
     readonly FIRST_KEY_INDEX: undefined;
-    readonly IS_READ_ONLY: true;
-    readonly transformArguments: (this: void, mode?: RedisFlushModes) => string[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, mode?: RedisFlushMode) => string[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/FUNCTION_FLUSH.js

@@ -5,3 +5,3 @@ "use strict";
     FIRST_KEY_INDEX: undefined,
-    IS_READ_ONLY: true,
+    IS_READ_ONLY: false,
     transformArguments(mode) {
@@ -8,0 +8,0 @@ const args = ['FUNCTION', 'FLUSH'];

dist/lib/commands/FUNCTION_LIST_WITHCODE.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// import { transformArguments as transformFunctionListArguments } from './FUNCTION_LIST';
-// import { FunctionListItemReply, FunctionListRawItemReply, transformFunctionListItemReply } from './generic-transformers';
-// export function transformArguments(pattern?: string): RedisCommandArguments {
-//     const args = transformFunctionListArguments(pattern);
-//     args.push('WITHCODE');
-//     return args;
-// }
-// type FunctionListWithCodeRawItemReply = [
-//     ...FunctionListRawItemReply,
-//     'library_code',
-//     string
-// ];
-// interface FunctionListWithCodeItemReply extends FunctionListItemReply {
-//     libraryCode: string;
-// }
-// export function transformReply(reply: Array<FunctionListWithCodeRawItemReply>): Array<FunctionListWithCodeItemReply> {
-//     return reply.map(library => ({
-//         ...transformFunctionListItemReply(library as unknown as FunctionListRawItemReply),
-//         libraryCode: library[7]
-//     }));
-// }
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FUNCTION_LIST_1 = __importDefault(require("./FUNCTION_LIST"));
+exports.default = {
+    FIRST_KEY_INDEX: FUNCTION_LIST_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: FUNCTION_LIST_1.default.IS_READ_ONLY,
+    transformArguments(...args) {
+        const redisArgs = FUNCTION_LIST_1.default.transformArguments(...args);
+        redisArgs.push('WITHCODE');
+        return redisArgs;
+    },
+    transformReply: {
+        2: (reply) => {
+            return reply.map((library) => ({
+                library_name: library[1],
+                engine: library[3],
+                functions: library[5].map((fn) => ({
+                    name: fn[1],
+                    description: fn[3],
+                    flags: fn[5]
+                })),
+                library_code: library[7]
+            }));
+        },
+        3: undefined
+    }
+};

dist/lib/commands/FUNCTION_LIST.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// import { FunctionListItemReply, FunctionListRawItemReply, transformFunctionListItemReply } from './generic-transformers';
-// export function transformArguments(pattern?: string): RedisCommandArguments {
-//     const args = ['FUNCTION', 'LIST'];
-//     if (pattern) {
-//         args.push(pattern);
-//     }
-//     return args;
-// }
-// export function transformReply(reply: Array<FunctionListRawItemReply>): Array<FunctionListItemReply> {
-//     return reply.map(transformFunctionListItemReply);
-// }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(options) {
+        const args = ['FUNCTION', 'LIST'];
+        if (options?.LIBRARYNAME) {
+            args.push('LIBRARYNAME', options.LIBRARYNAME);
+        }
+        return args;
+    },
+    transformReply: {
+        2: (reply) => {
+            return reply.map(library => ({
+                library_name: library[1],
+                engine: library[3],
+                functions: library[5].map(fn => ({
+                    name: fn[1],
+                    description: fn[3],
+                    flags: fn[5]
+                }))
+            }));
+        },
+        3: undefined
+    }
+};

dist/lib/commands/FUNCTION_LOAD.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// interface FunctionLoadOptions {
-//     REPLACE?: boolean;
-// }
-// export function transformArguments(
-//     code: string,
-//     options?: FunctionLoadOptions
-// ): RedisCommandArguments {
-//     const args = ['FUNCTION', 'LOAD'];
-//     if (options?.REPLACE) {
-//         args.push('REPLACE');
-//     }
-//     args.push(code);
-//     return args;
-// }
-// export declare function transformReply(): string;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(code, options) {
+        const args = ['FUNCTION', 'LOAD'];
+        if (options?.REPLACE) {
+            args.push('REPLACE');
+        }
+        args.push(code);
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/FUNCTION_RESTORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export function transformArguments(
-//     dump: RedisCommandArgument,
-//     mode?: 'FLUSH' | 'APPEND' | 'REPLACE'
-// ): RedisCommandArguments {
-//     const args = ['FUNCTION', 'RESTORE', dump];
-//     if (mode) {
-//         args.push(mode);
-//     }
-//     return args;
-// }
-// export declare function transformReply(): 'OK';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(dump, options) {
+        const args = ['FUNCTION', 'RESTORE', dump];
+        if (options?.mode) {
+            args.push(options.mode);
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/FUNCTION_STATS.js

 "use strict";
 // // import { RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // // export function transformArguments(): RedisCommandArguments {
@@ -4,0 +5,0 @@ // //     return ['FUNCTION', 'STATS'];

dist/lib/commands/generic-transformers.d.ts

@@ -1,8 +0,13 @@
-import { ArrayReply, BlobStringReply, CommandArguments, DoubleReply, NullReply, RedisArgument } from '../RESP/types';
+import { ArrayReply, BlobStringReply, CommandArguments, DoubleReply, NullReply, RedisArgument, TuplesReply } from '../RESP/types';
 export type BitValue = 0 | 1;
-export declare function transformDoubleReply(reply: BlobStringReply): number;
-export declare function transformNullableDoubleReply(reply: BlobStringReply | NullReply): number | null;
-export declare function transformArrayNullableDoubleReply(reply: Array<BlobStringReply | NullReply>): Array<number | null>;
 export declare function transformDoubleArgument(num: number): string;
 export declare function transformStringDoubleArgument(num: RedisArgument | number): RedisArgument;
+export declare const transformDoubleReply: {
+    2: (reply: BlobStringReply) => number;
+    3: () => DoubleReply;
+};
+export declare const transformNullableDoubleReply: {
+    2: (reply: BlobStringReply | NullReply) => number | null;
+    3: () => DoubleReply | NullReply;
+};
 export declare function transformTuplesReply(reply: ArrayReply<BlobStringReply>): Record<string, BlobStringReply>;
@@ -20,8 +25,7 @@ export interface StreamMessageReply {
 export declare function transformStreamsMessagesReply(reply: Array<any> | null): StreamsMessagesReply | null;
-export interface ZMember {
+export interface SortedSetMember {
+    value: RedisArgument;
     score: number;
-    value: RedisArgument;
 }
-export declare function transformSortedSetMemberNullReply(reply: [BlobStringReply, BlobStringReply] | []): ZMember | null;
-export declare function transformSortedSetMemberReply(reply: [BlobStringReply, BlobStringReply]): ZMember;
+export type SortedSetSide = 'MIN' | 'MAX';
 export declare const transformSortedSetReply: {
@@ -32,3 +36,3 @@ 2: (reply: ArrayReply<BlobStringReply>) => {
     }[];
-    3: (reply: ArrayReply<[BlobStringReply, DoubleReply]>) => {
+    3: (reply: ArrayReply<TuplesReply<[BlobStringReply, DoubleReply]>>) => {
         value: BlobStringReply;
@@ -38,56 +42,3 @@ score: DoubleReply;
 };
-export declare function transformSortedSetWithScoresReply(reply: ArrayReply<BlobStringReply>): Array<ZMember>;
 export type ListSide = 'LEFT' | 'RIGHT';
-export type SortedSetSide = 'MIN' | 'MAX';
-export interface LMPopOptions {
-    COUNT?: number;
-}
-export declare function transformLMPopArguments(args: CommandArguments, keys: RedisVariadicArgument, side: ListSide, options?: LMPopOptions): CommandArguments;
-type GeoCountArgument = number | {
-    value: number;
-    ANY?: true;
-};
-export declare function pushGeoCountArgument(args: CommandArguments, count: GeoCountArgument | undefined): CommandArguments;
-export type GeoUnits = 'm' | 'km' | 'mi' | 'ft';
-export interface GeoCoordinates {
-    longitude: RedisArgument | number;
-    latitude: RedisArgument | number;
-}
-type GeoSearchFromMember = string;
-export type GeoSearchFrom = GeoSearchFromMember | GeoCoordinates;
-interface GeoSearchByRadius {
-    radius: number;
-    unit: GeoUnits;
-}
-interface GeoSearchByBox {
-    width: number;
-    height: number;
-    unit: GeoUnits;
-}
-export type GeoSearchBy = GeoSearchByRadius | GeoSearchByBox;
-export interface GeoSearchOptions {
-    SORT?: 'ASC' | 'DESC';
-    COUNT?: GeoCountArgument;
-}
-export declare function pushGeoSearchArguments(args: CommandArguments, key: RedisArgument, from: GeoSearchFrom, by: GeoSearchBy, options?: GeoSearchOptions): CommandArguments;
-export declare function pushGeoRadiusArguments(args: CommandArguments, key: RedisArgument, from: GeoSearchFrom, radius: number, unit: GeoUnits, options?: GeoSearchOptions): CommandArguments;
-export interface GeoRadiusStoreOptions extends GeoSearchOptions {
-    STOREDIST?: boolean;
-}
-export declare function pushGeoRadiusStoreArguments(args: CommandArguments, key: RedisArgument, from: GeoSearchFrom, radius: number, unit: GeoUnits, destination: RedisArgument, options?: GeoRadiusStoreOptions): CommandArguments;
-export declare enum GeoReplyWith {
-    DISTANCE = "WITHDIST",
-    HASH = "WITHHASH",
-    COORDINATES = "WITHCOORD"
-}
-export interface GeoReplyWithMember {
-    member: string;
-    distance?: number;
-    hash?: string;
-    coordinates?: {
-        longitude: string;
-        latitude: string;
-    };
-}
-export declare function transformGeoMembersWithReply(reply: Array<Array<any>>, replyWith: Array<GeoReplyWith>): Array<GeoReplyWithMember>;
 export declare function transformEXAT(EXAT: number | Date): string;
@@ -209,2 +160,8 @@ export declare function transformPXAT(PXAT: number | Date): string;
 export declare function transformRangeReply([start, end]: RawRangeReply): RangeReply;
-export {};
+export type ZKeyAndWeight = {
+    key: RedisArgument;
+    weight: number;
+};
+export type ZVariadicKeys<T> = T | [T, ...Array<T>];
+export type ZKeys = ZVariadicKeys<RedisArgument> | ZVariadicKeys<ZKeyAndWeight>;
+export declare function pushZKeysArguments(args: CommandArguments, keys: ZKeys): CommandArguments;

dist/lib/commands/generic-transformers.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformRangeReply = exports.pushSlotRangesArguments = exports.transformFunctionListItemReply = exports.RedisFunctionFlags = exports.transformCommandReply = exports.CommandCategories = exports.CommandFlags = exports.pushOptionalVariadicArgument = exports.pushVariadicArgument = exports.pushVariadicNumberArguments = exports.pushVariadicArguments = exports.pushEvalArguments = exports.evalFirstKeyIndex = exports.transformPXAT = exports.transformEXAT = exports.transformGeoMembersWithReply = exports.GeoReplyWith = exports.pushGeoRadiusStoreArguments = exports.pushGeoRadiusArguments = exports.pushGeoSearchArguments = exports.pushGeoCountArgument = exports.transformLMPopArguments = exports.transformSortedSetWithScoresReply = exports.transformSortedSetReply = exports.transformSortedSetMemberReply = exports.transformSortedSetMemberNullReply = exports.transformStreamsMessagesReply = exports.transformStreamMessagesReply = exports.transformTuplesReply = exports.transformStringDoubleArgument = exports.transformDoubleArgument = exports.transformArrayNullableDoubleReply = exports.transformNullableDoubleReply = exports.transformDoubleReply = void 0;
-function transformDoubleReply(reply) {
-    switch (reply.toString()) {
-        case '+inf':
-            return Infinity;
-        case '-inf':
-            return -Infinity;
-        default:
-            return Number(reply);
-    }
-}
-exports.transformDoubleReply = transformDoubleReply;
-function transformNullableDoubleReply(reply) {
-    if (reply === null)
-        return null;
-    return transformDoubleReply(reply);
-}
-exports.transformNullableDoubleReply = transformNullableDoubleReply;
-function transformArrayNullableDoubleReply(reply) {
-    return reply.map(transformNullableDoubleReply);
-}
-exports.transformArrayNullableDoubleReply = transformArrayNullableDoubleReply;
+exports.pushZKeysArguments = exports.transformRangeReply = exports.pushSlotRangesArguments = exports.transformFunctionListItemReply = exports.RedisFunctionFlags = exports.transformCommandReply = exports.CommandCategories = exports.CommandFlags = exports.pushOptionalVariadicArgument = exports.pushVariadicArgument = exports.pushVariadicNumberArguments = exports.pushVariadicArguments = exports.pushEvalArguments = exports.evalFirstKeyIndex = exports.transformPXAT = exports.transformEXAT = exports.transformSortedSetReply = exports.transformStreamsMessagesReply = exports.transformStreamMessagesReply = exports.transformTuplesReply = exports.transformNullableDoubleReply = exports.transformDoubleReply = exports.transformStringDoubleArgument = exports.transformDoubleArgument = void 0;
 function transformDoubleArgument(num) {
@@ -42,2 +21,23 @@ switch (num) {
 exports.transformStringDoubleArgument = transformStringDoubleArgument;
+exports.transformDoubleReply = {
+    2: (reply) => {
+        switch (reply.toString()) {
+            case '+inf':
+                return Infinity;
+            case '-inf':
+                return -Infinity;
+            default:
+                return Number(reply);
+        }
+    },
+    3: undefined
+};
+exports.transformNullableDoubleReply = {
+    2: (reply) => {
+        if (reply === null)
+            return null;
+        return exports.transformDoubleReply[2](reply);
+    },
+    3: undefined
+};
 function transformTuplesReply(reply) {
@@ -71,15 +71,2 @@ const message = Object.create(null);
 exports.transformStreamsMessagesReply = transformStreamsMessagesReply;
-function transformSortedSetMemberNullReply(reply) {
-    if (!reply.length)
-        return null;
-    return transformSortedSetMemberReply(reply);
-}
-exports.transformSortedSetMemberNullReply = transformSortedSetMemberNullReply;
-function transformSortedSetMemberReply(reply) {
-    return {
-        value: reply[0],
-        score: transformDoubleReply(reply[1])
-    };
-}
-exports.transformSortedSetMemberReply = transformSortedSetMemberReply;
 exports.transformSortedSetReply = {
@@ -91,3 +78,3 @@ 2: (reply) => {
                 value: reply[i],
-                score: transformDoubleReply(reply[i + 1])
+                score: exports.transformDoubleReply[2](reply[i + 1])
             });
@@ -104,115 +91,2 @@ }
 };
-function transformSortedSetWithScoresReply(reply) {
-    const members = [];
-    for (let i = 0; i < reply.length; i += 2) {
-        members.push({
-            value: reply[i],
-            score: transformDoubleReply(reply[i + 1])
-        });
-    }
-    return members;
-}
-exports.transformSortedSetWithScoresReply = transformSortedSetWithScoresReply;
-function transformLMPopArguments(args, keys, side, options) {
-    pushVariadicArgument(args, keys);
-    args.push(side);
-    if (options?.COUNT) {
-        args.push('COUNT', options.COUNT.toString());
-    }
-    return args;
-}
-exports.transformLMPopArguments = transformLMPopArguments;
-function pushGeoCountArgument(args, count) {
-    if (typeof count === 'number') {
-        args.push('COUNT', count.toString());
-    }
-    else if (count) {
-        args.push('COUNT', count.value.toString());
-        if (count.ANY) {
-            args.push('ANY');
-        }
-    }
-    return args;
-}
-exports.pushGeoCountArgument = pushGeoCountArgument;
-function pushGeoSearchArguments(args, key, from, by, options) {
-    args.push(key);
-    if (typeof from === 'string') {
-        args.push('FROMMEMBER', from);
-    }
-    else {
-        args.push('FROMLONLAT', from.longitude.toString(), from.latitude.toString());
-    }
-    if ('radius' in by) {
-        args.push('BYRADIUS', by.radius.toString());
-    }
-    else {
-        args.push('BYBOX', by.width.toString(), by.height.toString());
-    }
-    args.push(by.unit);
-    if (options?.SORT) {
-        args.push(options.SORT);
-    }
-    pushGeoCountArgument(args, options?.COUNT);
-    return args;
-}
-exports.pushGeoSearchArguments = pushGeoSearchArguments;
-function pushGeoRadiusArguments(args, key, from, radius, unit, options) {
-    args.push(key);
-    if (typeof from === 'string') {
-        args.push(from);
-    }
-    else {
-        args.push(from.longitude.toString(), from.latitude.toString());
-    }
-    args.push(radius.toString(), unit);
-    if (options?.SORT) {
-        args.push(options.SORT);
-    }
-    pushGeoCountArgument(args, options?.COUNT);
-    return args;
-}
-exports.pushGeoRadiusArguments = pushGeoRadiusArguments;
-function pushGeoRadiusStoreArguments(args, key, from, radius, unit, destination, options) {
-    pushGeoRadiusArguments(args, key, from, radius, unit, options);
-    if (options?.STOREDIST) {
-        args.push('STOREDIST', destination);
-    }
-    else {
-        args.push('STORE', destination);
-    }
-    return args;
-}
-exports.pushGeoRadiusStoreArguments = pushGeoRadiusStoreArguments;
-var GeoReplyWith;
-(function (GeoReplyWith) {
-    GeoReplyWith["DISTANCE"] = "WITHDIST";
-    GeoReplyWith["HASH"] = "WITHHASH";
-    GeoReplyWith["COORDINATES"] = "WITHCOORD";
-})(GeoReplyWith = exports.GeoReplyWith || (exports.GeoReplyWith = {}));
-function transformGeoMembersWithReply(reply, replyWith) {
-    const replyWithSet = new Set(replyWith);
-    let index = 0;
-    const distanceIndex = replyWithSet.has(GeoReplyWith.DISTANCE) && ++index, hashIndex = replyWithSet.has(GeoReplyWith.HASH) && ++index, coordinatesIndex = replyWithSet.has(GeoReplyWith.COORDINATES) && ++index;
-    return reply.map(member => {
-        const transformedMember = {
-            member: member[0]
-        };
-        if (distanceIndex) {
-            transformedMember.distance = member[distanceIndex];
-        }
-        if (hashIndex) {
-            transformedMember.hash = member[hashIndex];
-        }
-        if (coordinatesIndex) {
-            const [longitude, latitude] = member[coordinatesIndex];
-            transformedMember.coordinates = {
-                longitude,
-                latitude
-            };
-        }
-        return transformedMember;
-    });
-}
-exports.transformGeoMembersWithReply = transformGeoMembersWithReply;
 function transformEXAT(EXAT) {
@@ -299,3 +173,3 @@ return (typeof EXAT === 'number' ? EXAT : Math.floor(EXAT.getTime() / 1000)).toString();
     CommandFlags["MOVABLEKEYS"] = "movablekeys"; // keys have no pre-determined position. You must discover keys yourself.
-})(CommandFlags = exports.CommandFlags || (exports.CommandFlags = {}));
+})(CommandFlags || (exports.CommandFlags = CommandFlags = {}));
 var CommandCategories;
@@ -324,3 +198,3 @@ (function (CommandCategories) {
     CommandCategories["SCRIPTING"] = "@scripting";
-})(CommandCategories = exports.CommandCategories || (exports.CommandCategories = {}));
+})(CommandCategories || (exports.CommandCategories = CommandCategories = {}));
 function transformCommandReply([name, arity, flags, firstKeyIndex, lastKeyIndex, step, categories]) {
@@ -344,3 +218,3 @@ return {
     RedisFunctionFlags["NO_CLUSTER"] = "no-cluster";
-})(RedisFunctionFlags = exports.RedisFunctionFlags || (exports.RedisFunctionFlags = {}));
+})(RedisFunctionFlags || (exports.RedisFunctionFlags = RedisFunctionFlags = {}));
 function transformFunctionListItemReply(reply) {
@@ -380,1 +254,37 @@ return {
 exports.transformRangeReply = transformRangeReply;
+function pushZKeysArguments(args, keys) {
+    if (Array.isArray(keys)) {
+        args.push(keys.length.toString());
+        if (keys.length) {
+            if (isPlainKeys(keys)) {
+                args = args.concat(keys);
+            }
+            else {
+                const start = args.length;
+                args[start + keys.length] = 'WEIGHTS';
+                for (let i = 0; i < keys.length; i++) {
+                    const index = start + i;
+                    args[index] = keys[i].key;
+                    args[index + 1 + keys.length] = transformDoubleArgument(keys[i].weight);
+                }
+            }
+        }
+    }
+    else {
+        args.push('1');
+        if (isPlainKey(keys)) {
+            args.push(keys);
+        }
+        else {
+            args.push(keys.key, 'WEIGHTS', transformDoubleArgument(keys.weight));
+        }
+    }
+    return args;
+}
+exports.pushZKeysArguments = pushZKeysArguments;
+function isPlainKey(key) {
+    return typeof key === 'string' || key instanceof Buffer;
+}
+function isPlainKeys(keys) {
+    return isPlainKey(keys[0]);
+}

dist/lib/commands/GEOADD.d.ts

 import { RedisArgument, NumberReply } from '../RESP/types';
-import { GeoCoordinates } from './generic-transformers';
-interface GeoMember extends GeoCoordinates {
+import { GeoCoordinates } from './GEOSEARCH';
+export interface GeoMember extends GeoCoordinates {
     member: RedisArgument;
 }
-interface GeoAddOptions {
-    condition: 'NX' | 'XX';
+export interface GeoAddOptions {
+    condition?: 'NX' | 'XX';
     /**
@@ -9,0 +9,0 @@ * @deprecated Use `{ condition: 'NX' }` instead.

dist/lib/commands/GEODIST.d.ts

 import { RedisArgument, BlobStringReply, NullReply } from '../RESP/types';
-import { GeoUnits } from './generic-transformers';
+import { GeoUnits } from './GEOSEARCH';
 declare const _default: {
@@ -4,0 +4,0 @@ readonly FIRST_KEY_INDEX: 1;

dist/lib/commands/GEORADIUS_RO_WITH.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoReplyWith, GeoSearchOptions, GeoCoordinates, GeoUnits } from './generic-transformers';
-// import { transformArguments as transformGeoRadiusRoArguments } from './GEORADIUS_RO';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUS_RO';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     coordinates: GeoCoordinates,
-//     radius: number,
-//     unit: GeoUnits,
-//     replyWith: Array<GeoReplyWith>,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     const args: RedisCommandArguments = transformGeoRadiusRoArguments(
-//         key,
-//         coordinates,
-//         radius,
-//         unit,
-//         options
-//     );
-//     args.push(...replyWith);
-//     args.preserve = replyWith;
-//     return args;
-// }
-// export { transformGeoMembersWithReply as transformReply } from './generic-transformers';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GEORADIUS_WITH_1 = __importStar(require("./GEORADIUS_WITH"));
+exports.default = {
+    FIRST_KEY_INDEX: GEORADIUS_WITH_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: true,
+    transformArguments: GEORADIUS_WITH_1.transformGeoRadiusWithArguments.bind(undefined, 'GEORADIUS_RO'),
+    transformReply: GEORADIUS_WITH_1.default.transformReply
+};

dist/lib/commands/GEORADIUS_RO.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchOptions, GeoCoordinates, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     coordinates: GeoCoordinates,
-//     radius: number,
-//     unit: GeoUnits,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     return pushGeoRadiusArguments(
-//         ['GEORADIUS_RO'],
-//         key,
-//         coordinates,
-//         radius,
-//         unit,
-//         options
-//     );
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GEORADIUS_1 = __importStar(require("./GEORADIUS"));
+exports.default = {
+    FIRST_KEY_INDEX: GEORADIUS_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: true,
+    transformArguments: GEORADIUS_1.transformGeoRadiusArguments.bind(undefined, 'GEORADIUS_RO'),
+    transformReply: GEORADIUS_1.default.transformReply
+};

dist/lib/commands/GEORADIUS_WITH.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoReplyWith, GeoSearchOptions, GeoCoordinates, GeoUnits } from './generic-transformers';
-// import { transformArguments as transformGeoRadiusArguments } from './GEORADIUS';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUS';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     coordinates: GeoCoordinates,
-//     radius: number,
-//     unit: GeoUnits,
-//     replyWith: Array<GeoReplyWith>,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     const args: RedisCommandArguments = transformGeoRadiusArguments(
-//         key,
-//         coordinates,
-//         radius,
-//         unit,
-//         options
-//     );
-//     args.push(...replyWith);
-//     args.preserve = replyWith;
-//     return args;
-// }
-// export { transformGeoMembersWithReply as transformReply } from './generic-transformers';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGeoRadiusWithArguments = void 0;
+const GEORADIUS_1 = __importStar(require("./GEORADIUS"));
+const GEOSEARCH_WITH_1 = __importDefault(require("./GEOSEARCH_WITH"));
+function transformGeoRadiusWithArguments(command, key, from, radius, unit, replyWith, options) {
+    const args = (0, GEORADIUS_1.transformGeoRadiusArguments)(command, key, from, radius, unit, options);
+    args.push(...replyWith);
+    args.preserve = replyWith;
+    return args;
+}
+exports.transformGeoRadiusWithArguments = transformGeoRadiusWithArguments;
+exports.default = {
+    FIRST_KEY_INDEX: GEORADIUS_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: GEORADIUS_1.default.IS_READ_ONLY,
+    transformArguments: transformGeoRadiusWithArguments.bind(undefined, 'GEORADIUS'),
+    transformReply: GEOSEARCH_WITH_1.default.transformReply
+};

dist/lib/commands/GEORADIUS.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchOptions, GeoCoordinates, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     coordinates: GeoCoordinates,
-//     radius: number,
-//     unit: GeoUnits,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     return pushGeoRadiusArguments(
-//         ['GEORADIUS'],
-//         key,
-//         coordinates,
-//         radius,
-//         unit,
-//         options
-//     );
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGeoRadiusArguments = void 0;
+const GEOSEARCH_1 = require("./GEOSEARCH");
+function transformGeoRadiusArguments(command, key, from, radius, unit, options) {
+    const args = [
+        command,
+        key,
+        from.longitude.toString(),
+        from.latitude.toString(),
+        radius.toString(),
+        unit
+    ];
+    (0, GEOSEARCH_1.pushGeoSearchOptions)(args, options);
+    return args;
+}
+exports.transformGeoRadiusArguments = transformGeoRadiusArguments;
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments: transformGeoRadiusArguments.bind(undefined, 'GEORADIUS'),
+    transformReply: undefined
+};

dist/lib/commands/GEORADIUSBYMEMBER_RO_WITH.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoReplyWith, GeoSearchOptions, GeoUnits } from './generic-transformers';
-// import { transformArguments as geoRadiusTransformArguments } from './GEORADIUSBYMEMBER_RO';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUSBYMEMBER_RO';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     member: string,
-//     radius: number,
-//     unit: GeoUnits,
-//     replyWith: Array<GeoReplyWith>,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     const args: RedisCommandArguments = geoRadiusTransformArguments(
-//         key,
-//         member,
-//         radius,
-//         unit,
-//         options
-//     );
-//     args.push(...replyWith);
-//     args.preserve = replyWith;
-//     return args;
-// }
-// export { transformGeoMembersWithReply as transformReply } from './generic-transformers';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GEORADIUSBYMEMBER_WITH_1 = __importStar(require("./GEORADIUSBYMEMBER_WITH"));
+exports.default = {
+    FIRST_KEY_INDEX: GEORADIUSBYMEMBER_WITH_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: true,
+    transformArguments: GEORADIUSBYMEMBER_WITH_1.transformGeoRadiusByMemberWithArguments.bind(undefined, 'GEORADIUSBYMEMBER_RO'),
+    transformReply: GEORADIUSBYMEMBER_WITH_1.default.transformReply
+};

dist/lib/commands/GEORADIUSBYMEMBER_RO.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchOptions, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     member: string,
-//     radius: number,
-//     unit: GeoUnits,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     return pushGeoRadiusArguments(
-//         ['GEORADIUSBYMEMBER_RO'],
-//         key,
-//         member,
-//         radius,
-//         unit,
-//         options
-//     );
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const GEORADIUSBYMEMBER_1 = __importStar(require("./GEORADIUSBYMEMBER"));
+exports.default = {
+    FIRST_KEY_INDEX: GEORADIUSBYMEMBER_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: true,
+    transformArguments: GEORADIUSBYMEMBER_1.transformGeoRadiusByMemberArguments.bind(undefined, 'GEORADIUSBYMEMBER_RO'),
+    transformReply: GEORADIUSBYMEMBER_1.default.transformReply
+};

dist/lib/commands/GEORADIUSBYMEMBER_WITH.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoReplyWith, GeoSearchOptions, GeoUnits } from './generic-transformers';
-// import { transformArguments as transformGeoRadiusArguments } from './GEORADIUSBYMEMBER';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUSBYMEMBER';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     member: string,
-//     radius: number,
-//     unit: GeoUnits,
-//     replyWith: Array<GeoReplyWith>,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     const args: RedisCommandArguments = transformGeoRadiusArguments(
-//         key,
-//         member,
-//         radius,
-//         unit,
-//         options
-//     );
-//     args.push(...replyWith);
-//     args.preserve = replyWith;
-//     return args;
-// }
-// export { transformGeoMembersWithReply as transformReply } from './generic-transformers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGeoRadiusByMemberWithArguments = void 0;
+const GEORADIUSBYMEMBER_1 = __importDefault(require("./GEORADIUSBYMEMBER"));
+const GEOSEARCH_1 = require("./GEOSEARCH");
+const GEOSEARCH_WITH_1 = __importDefault(require("./GEOSEARCH_WITH"));
+function transformGeoRadiusByMemberWithArguments(command, key, from, radius, unit, replyWith, options) {
+    const args = [
+        command,
+        key,
+        from,
+        radius.toString(),
+        unit
+    ];
+    (0, GEOSEARCH_1.pushGeoSearchOptions)(args, options);
+    args.push(...replyWith);
+    args.preserve = replyWith;
+    return args;
+}
+exports.transformGeoRadiusByMemberWithArguments = transformGeoRadiusByMemberWithArguments;
+exports.default = {
+    FIRST_KEY_INDEX: GEORADIUSBYMEMBER_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: GEORADIUSBYMEMBER_1.default.IS_READ_ONLY,
+    transformArguments: transformGeoRadiusByMemberWithArguments.bind(undefined, 'GEORADIUSBYMEMBER'),
+    transformReply: GEOSEARCH_WITH_1.default.transformReply
+};

dist/lib/commands/GEORADIUSBYMEMBER.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchOptions, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     member: string,
-//     radius: number,
-//     unit: GeoUnits,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     return pushGeoRadiusArguments(
-//         ['GEORADIUSBYMEMBER'],
-//         key,
-//         member,
-//         radius,
-//         unit,
-//         options
-//     );
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGeoRadiusByMemberArguments = void 0;
+const GEOSEARCH_1 = require("./GEOSEARCH");
+function transformGeoRadiusByMemberArguments(command, key, from, radius, unit, options) {
+    const args = [
+        command,
+        key,
+        from,
+        radius.toString(),
+        unit
+    ];
+    (0, GEOSEARCH_1.pushGeoSearchOptions)(args, options);
+    return args;
+}
+exports.transformGeoRadiusByMemberArguments = transformGeoRadiusByMemberArguments;
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments: transformGeoRadiusByMemberArguments.bind(undefined, 'GEORADIUSBYMEMBER'),
+    transformReply: undefined
+};

dist/lib/commands/GEOSEARCH_WITH.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchFrom, GeoSearchBy, GeoReplyWith, GeoSearchOptions } from './generic-transformers';
-// import { transformArguments as geoSearchTransformArguments } from './GEOSEARCH';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEOSEARCH';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     from: GeoSearchFrom,
-//     by: GeoSearchBy,
-//     replyWith: Array<GeoReplyWith>,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     const args: RedisCommandArguments = geoSearchTransformArguments(key, from, by, options);
-//     args.push(...replyWith);
-//     args.preserve = replyWith;
-//     return args;
-// }
-// export { transformGeoMembersWithReply as transformReply } from './generic-transformers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEO_REPLY_WITH = void 0;
+const GEOSEARCH_1 = __importDefault(require("./GEOSEARCH"));
+exports.GEO_REPLY_WITH = {
+    DISTANCE: 'WITHDIST',
+    HASH: 'WITHHASH',
+    COORDINATES: 'WITHCOORD'
+};
+exports.default = {
+    FIRST_KEY_INDEX: GEOSEARCH_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: GEOSEARCH_1.default.IS_READ_ONLY,
+    transformArguments(key, from, by, replyWith, options) {
+        const args = GEOSEARCH_1.default.transformArguments(key, from, by, options);
+        args.push(...replyWith);
+        args.preserve = replyWith;
+        return args;
+    },
+    transformReply(reply, replyWith) {
+        const replyWithSet = new Set(replyWith);
+        let index = 0;
+        const distanceIndex = replyWithSet.has(exports.GEO_REPLY_WITH.DISTANCE) && ++index, hashIndex = replyWithSet.has(exports.GEO_REPLY_WITH.HASH) && ++index, coordinatesIndex = replyWithSet.has(exports.GEO_REPLY_WITH.COORDINATES) && ++index;
+        return reply.map(raw => {
+            const item = {
+                member: raw[0]
+            };
+            if (distanceIndex) {
+                item.distance = raw[distanceIndex];
+            }
+            if (hashIndex) {
+                item.hash = raw[hashIndex];
+            }
+            if (coordinatesIndex) {
+                const [longitude, latitude] = raw[coordinatesIndex];
+                item.coordinates = {
+                    longitude,
+                    latitude
+                };
+            }
+            return item;
+        });
+    }
+};

dist/lib/commands/GEOSEARCH.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     from: GeoSearchFrom,
-//     by: GeoSearchBy,
-//     options?: GeoSearchOptions
-// ): RedisCommandArguments {
-//     return pushGeoSearchArguments(['GEOSEARCH'], key, from, by, options);
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushGeoSearchOptions = exports.pushGeoSearchArguments = void 0;
+function pushGeoSearchArguments(args, key, from, by, options) {
+    args.push(key);
+    if (typeof from === 'string' || from instanceof Buffer) {
+        args.push('FROMMEMBER', from);
+    }
+    else {
+        args.push('FROMLONLAT', from.longitude.toString(), from.latitude.toString());
+    }
+    if ('radius' in by) {
+        args.push('BYRADIUS', by.radius.toString(), by.unit);
+    }
+    else {
+        args.push('BYBOX', by.width.toString(), by.height.toString(), by.unit);
+    }
+    pushGeoSearchOptions(args, options);
+    return args;
+}
+exports.pushGeoSearchArguments = pushGeoSearchArguments;
+function pushGeoSearchOptions(args, options) {
+    if (options?.SORT) {
+        args.push(options.SORT);
+    }
+    if (options?.COUNT) {
+        if (typeof options.COUNT === 'number') {
+            args.push('COUNT', options.COUNT.toString());
+        }
+        else {
+            args.push('COUNT', options.COUNT.value.toString());
+            if (options.COUNT.ANY) {
+                args.push('ANY');
+            }
+        }
+    }
+}
+exports.pushGeoSearchOptions = pushGeoSearchOptions;
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: true,
+    transformArguments(key, from, by, options) {
+        return pushGeoSearchArguments(['GEOSEARCH'], key, from, by, options);
+    },
+    transformReply: undefined
+};

dist/lib/commands/GEOSEARCHSTORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEOSEARCH';
-// interface GeoSearchStoreOptions extends GeoSearchOptions {
-//     STOREDIST?: true;
-// }
-// export function transformArguments(
-//     destination: RedisCommandArgument,
-//     source: RedisCommandArgument,
-//     from: GeoSearchFrom,
-//     by: GeoSearchBy,
-//     options?: GeoSearchStoreOptions
-// ): RedisCommandArguments {
-//     const args = pushGeoSearchArguments(
-//         ['GEOSEARCHSTORE', destination],
-//         source,
-//         from,
-//         by,
-//         options
-//     );
-//     if (options?.STOREDIST) {
-//         args.push('STOREDIST');
-//     }
-//     return args;
-// }
-// export function transformReply(reply: number): number {
-//     if (typeof reply !== 'number') {
-//         throw new TypeError(`https://github.com/redis/redis/issues/9261`);
-//     }
-//     return reply;
-// }
+Object.defineProperty(exports, "__esModule", { value: true });
+const GEOSEARCH_1 = require("./GEOSEARCH");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(destination, source, from, by, options) {
+        const args = (0, GEOSEARCH_1.pushGeoSearchArguments)(['GEOSEARCHSTORE', destination], source, from, by, options);
+        if (options?.STOREDIST) {
+            args.push('STOREDIST');
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/GETEX.d.ts

 import { RedisArgument, BlobStringReply, NullReply } from '../RESP/types';
-export type GetExModes = {
+export type GetExOptions = {
+    type: 'EX' | 'PX';
+    value: number;
+} | {
+    type: 'EXAT' | 'PXAT';
+    value: number | Date;
+} | {
+    type: 'PERSIST';
+} | {
+    /**
+     * @deprecated Use `{ type: 'EX', value: number }` instead.
+     */
     EX: number;
 } | {
+    /**
+     * @deprecated Use `{ type: 'PX', value: number }` instead.
+     */
     PX: number;
 } | {
+    /**
+     * @deprecated Use `{ type: 'EXAT', value: number | Date }` instead.
+     */
     EXAT: number | Date;
 } | {
+    /**
+     * @deprecated Use `{ type: 'PXAT', value: number | Date }` instead.
+     */
     PXAT: number | Date;
 } | {
+    /**
+     * @deprecated Use `{ type: 'PERSIST' }` instead.
+     */
     PERSIST: true;
@@ -16,5 +39,5 @@ };
     readonly IS_READ_ONLY: true;
-    readonly transformArguments: (this: void, key: RedisArgument, mode: GetExModes) => RedisArgument[];
+    readonly transformArguments: (this: void, key: RedisArgument, options: GetExOptions) => RedisArgument[];
     readonly transformReply: () => BlobStringReply | NullReply;
 };
 export default _default;

dist/lib/commands/GETEX.js

@@ -7,19 +7,36 @@ "use strict";
     IS_READ_ONLY: true,
-    transformArguments(key, mode) {
+    transformArguments(key, options) {
         const args = ['GETEX', key];
-        if ('EX' in mode) {
-            args.push('EX', mode.EX.toString());
+        if ('type' in options) {
+            switch (options.type) {
+                case 'EX':
+                case 'PX':
+                    args.push(options.type, options.value.toString());
+                    break;
+                case 'EXAT':
+                case 'PXAT':
+                    args.push(options.type, (0, generic_transformers_1.transformEXAT)(options.value));
+                    break;
+                case 'PERSIST':
+                    args.push('PERSIST');
+                    break;
+            }
         }
-        else if ('PX' in mode) {
-            args.push('PX', mode.PX.toString());
+        else {
+            if ('EX' in options) {
+                args.push('EX', options.EX.toString());
+            }
+            else if ('PX' in options) {
+                args.push('PX', options.PX.toString());
+            }
+            else if ('EXAT' in options) {
+                args.push('EXAT', (0, generic_transformers_1.transformEXAT)(options.EXAT));
+            }
+            else if ('PXAT' in options) {
+                args.push('PXAT', (0, generic_transformers_1.transformPXAT)(options.PXAT));
+            }
+            else { // PERSIST
+                args.push('PERSIST');
+            }
         }
-        else if ('EXAT' in mode) {
-            args.push('EXAT', (0, generic_transformers_1.transformEXAT)(mode.EXAT));
-        }
-        else if ('PXAT' in mode) {
-            args.push('PXAT', (0, generic_transformers_1.transformPXAT)(mode.PXAT));
-        }
-        else { // PERSIST
-            args.push('PERSIST');
-        }
         return args;
@@ -26,0 +43,0 @@ },

dist/lib/commands/HELLO.d.ts

@@ -1,4 +0,4 @@
-/// <reference types="node" />
 import { RedisArgument, ArrayReply, BlobStringReply, NumberReply, Resp2Reply, RespVersions, TuplesToMapReply } from '../RESP/types';
 export interface HelloOptions {
+    protover?: RespVersions;
     AUTH?: {
@@ -41,61 +41,16 @@ username: RedisArgument;
 declare const _default: {
-    readonly transformArguments: (this: void, protoover: RespVersions, options?: HelloOptions) => RedisArgument[];
+    readonly transformArguments: (this: void, protover?: RespVersions, options?: HelloOptions) => RedisArgument[];
     readonly transformReply: {
         readonly 2: (reply: Resp2Reply<HelloReply>) => {
-            server: (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            };
-            version: (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            };
-            proto: (RespVersions | "2" | "3") & {
-                RESP_TYPE: 58;
-                DEFAULT: RespVersions;
-                TYPES: "2" | "3";
-                FLAG: import("../RESP/types").Flag<RespVersions | "2" | "3">;
-            };
-            id: (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            };
-            mode: (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            };
-            role: (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            };
-            modules: ((string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            })[] & {
+            server: BlobStringReply;
+            version: BlobStringReply;
+            proto: NumberReply<RespVersions>;
+            id: NumberReply;
+            mode: BlobStringReply;
+            role: BlobStringReply;
+            modules: BlobStringReply[] & {
                 RESP_TYPE: 42;
-                DEFAULT: ((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[];
+                DEFAULT: BlobStringReply[];
                 TYPES: never;
-                FLAG: import("../RESP/types").Flag<((string | Buffer) & {
-                    RESP_TYPE: 36;
-                    DEFAULT: string;
-                    TYPES: Buffer;
-                    FLAG: import("../RESP/types").Flag<string | Buffer>;
-                })[]>;
+                FLAG: import("../RESP/types").Flag<BlobStringReply[]>;
             };
@@ -102,0 +57,0 @@ };

dist/lib/commands/HELLO.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
-    transformArguments(protoover, options) {
-        const args = ['HELLO', protoover.toString()];
-        if (options?.AUTH) {
-            args.push('AUTH', options.AUTH.username, options.AUTH.password);
+    transformArguments(protover, options) {
+        const args = ['HELLO'];
+        if (protover) {
+            args.push(protover.toString());
+            if (options?.AUTH) {
+                args.push('AUTH', options.AUTH.username, options.AUTH.password);
+            }
+            if (options?.SETNAME) {
+                args.push('SETNAME', options.SETNAME);
+            }
         }
-        if (options?.SETNAME) {
-            args.push('SETNAME', options.SETNAME);
-        }
         return args;
@@ -13,0 +16,0 @@ },

dist/lib/commands/HMGET.js

@@ -8,5 +8,5 @@ "use strict";
     transformArguments(key, fields) {
-        return (0, generic_transformers_1.pushVariadicArguments)(['HMGET'], fields);
+        return (0, generic_transformers_1.pushVariadicArguments)(['HMGET', key], fields);
     },
     transformReply: undefined
 };

dist/lib/commands/HSET.js

@@ -7,3 +7,3 @@ "use strict";
         const args = ['HSET', key];
-        if (typeof value === 'string' || typeof value === 'number' || Buffer.isBuffer(value)) {
+        if (typeof value === 'string' || typeof value === 'number' || value instanceof Buffer) {
             args.push(convertValue(value), convertValue(fieldValue));
@@ -10,0 +10,0 @@ }

dist/lib/commands/HSTRLEN.js

@@ -7,5 +7,5 @@ "use strict";
     transformArguments(key, field) {
-        return ['HSETLEN', key, field];
+        return ['HSTRLEN', key, field];
     },
     transformReply: undefined
 };

dist/lib/commands/index.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ACL_CAT_1 = require("./ACL_CAT");
-const ACL_DRYRUN_1 = require("./ACL_DRYRUN");
-const ACL_GENPASS_1 = require("./ACL_GENPASS");
-const ACL_GETUSER_1 = require("./ACL_GETUSER");
-const ACL_LIST_1 = require("./ACL_LIST");
-const ACL_LOAD_1 = require("./ACL_LOAD");
-const ACL_LOG_RESET_1 = require("./ACL_LOG_RESET");
-const ACL_LOG_1 = require("./ACL_LOG");
-const ACL_SAVE_1 = require("./ACL_SAVE");
-const ACL_SETUSER_1 = require("./ACL_SETUSER");
-const ACL_USERS_1 = require("./ACL_USERS");
-const ACL_WHOAMI_1 = require("./ACL_WHOAMI");
-const APPEND_1 = require("./APPEND");
-const ASKING_1 = require("./ASKING");
-const AUTH_1 = require("./AUTH");
-const BGREWRITEAOF_1 = require("./BGREWRITEAOF");
-const BGSAVE_1 = require("./BGSAVE");
-const BITCOUNT_1 = require("./BITCOUNT");
-const BITFIELD_RO_1 = require("./BITFIELD_RO");
-const BITFIELD_1 = require("./BITFIELD");
-const BITOP_1 = require("./BITOP");
-const BITPOS_1 = require("./BITPOS");
-const BLMOVE_1 = require("./BLMOVE");
-const BLMPOP_1 = require("./BLMPOP");
-const BLPOP_1 = require("./BLPOP");
-const BRPOP_1 = require("./BRPOP");
-const BRPOPLPUSH_1 = require("./BRPOPLPUSH");
-const CLIENT_CACHING_1 = require("./CLIENT_CACHING");
-const CLIENT_GETNAME_1 = require("./CLIENT_GETNAME");
-const CLIENT_GETREDIR_1 = require("./CLIENT_GETREDIR");
-const CLIENT_ID_1 = require("./CLIENT_ID");
-const CLIENT_INFO_1 = require("./CLIENT_INFO");
-const CLIENT_KILL_1 = require("./CLIENT_KILL");
-const CLIENT_LIST_1 = require("./CLIENT_LIST");
-const CLIENT_NO_EVICT_1 = require("./CLIENT_NO-EVICT");
-const CLIENT_PAUSE_1 = require("./CLIENT_PAUSE");
-const CLIENT_SETNAME_1 = require("./CLIENT_SETNAME");
-const CLUSTER_ADDSLOTS_1 = require("./CLUSTER_ADDSLOTS");
-const CLUSTER_SLOTS_1 = require("./CLUSTER_SLOTS");
-const CLUSTER_MEET_1 = require("./CLUSTER_MEET");
-const CLUSTER_MYID_1 = require("./CLUSTER_MYID");
-const CLUSTER_REPLICATE_1 = require("./CLUSTER_REPLICATE");
-const DECR_1 = require("./DECR");
-const DECRBY_1 = require("./DECRBY");
-const GET_1 = require("./GET");
-const GETDEL_1 = require("./GETDEL");
-const GETEX_1 = require("./GETEX");
-const GETRANGE_1 = require("./GETRANGE");
-const GETSET_1 = require("./GETSET");
-const FLUSHALL_1 = require("./FLUSHALL");
-const HDEL_1 = require("./HDEL");
-const HEXISTS_1 = require("./HEXISTS");
-const HGET_1 = require("./HGET");
-const HGETALL_1 = require("./HGETALL");
-const HINCRBY_1 = require("./HINCRBY");
-const HINCRBYFLOAT_1 = require("./HINCRBYFLOAT");
-const HKEYS_1 = require("./HKEYS");
-const HLEN_1 = require("./HLEN");
-const HMGET_1 = require("./HMGET");
-const HRANDFIELD_COUNT_WITHVALUES_1 = require("./HRANDFIELD_COUNT_WITHVALUES");
-const HRANDFIELD_COUNT_1 = require("./HRANDFIELD_COUNT");
-const HRANDFIELD_1 = require("./HRANDFIELD");
-const HSCAN_1 = require("./HSCAN");
-const HSET_1 = require("./HSET");
-const HSETNX_1 = require("./HSETNX");
-const HSTRLEN_1 = require("./HSTRLEN");
-const HVALS_1 = require("./HVALS");
-const INCR_1 = require("./INCR");
-const INCRBY_1 = require("./INCRBY");
-const INCRBYFLOAT_1 = require("./INCRBYFLOAT");
-const INFO_1 = require("./INFO");
-// import LCS_IDX_WITHMATCHLEN from './LCS_IDX_WITHMATCHLEN';
-// import LCS_IDX from './LCS_IDX';
-const LCS_LEN_1 = require("./LCS_LEN");
-const LCS_1 = require("./LCS");
-const LINDEX_1 = require("./LINDEX");
-const LINSERT_1 = require("./LINSERT");
-const LLEN_1 = require("./LLEN");
-const LMOVE_1 = require("./LMOVE");
-const LMPOP_1 = require("./LMPOP");
-const LPOP_COUNT_1 = require("./LPOP_COUNT");
-const LPOP_1 = require("./LPOP");
-const LPOS_COUNT_1 = require("./LPOS_COUNT");
-const LPOS_1 = require("./LPOS");
-const LPUSH_1 = require("./LPUSH");
-const LPUSHX_1 = require("./LPUSHX");
-const LRANGE_1 = require("./LRANGE");
-const LREM_1 = require("./LREM");
-const LSET_1 = require("./LSET");
-const LTRIM_1 = require("./LTRIM");
-const MGET_1 = require("./MGET");
-const MSET_1 = require("./MSET");
-const MSETNX_1 = require("./MSETNX");
-const PFADD_1 = require("./PFADD");
-const PFCOUNT_1 = require("./PFCOUNT");
-const PFMERGE_1 = require("./PFMERGE");
-const PING_1 = require("./PING");
-const PSETEX_1 = require("./PSETEX");
-const RENAME_1 = require("./RENAME");
-const RENAMENX_1 = require("./RENAMENX");
-const RPOP_COUNT_1 = require("./RPOP_COUNT");
-const RPOP_1 = require("./RPOP");
-const RPOPLPUSH_1 = require("./RPOPLPUSH");
-const RPUSH_1 = require("./RPUSH");
-const RPUSHX_1 = require("./RPUSHX");
-const SADD_1 = require("./SADD");
-const SCAN_1 = require("./SCAN");
-const SCARD_1 = require("./SCARD");
-const SDIFF_1 = require("./SDIFF");
-const SDIFFSTORE_1 = require("./SDIFFSTORE");
-const SET_1 = require("./SET");
-const SETBIT_1 = require("./SETBIT");
-const SETEX_1 = require("./SETEX");
-const SETNX_1 = require("./SETNX");
-const SETRANGE_1 = require("./SETRANGE");
-const SINTER_1 = require("./SINTER");
-const SINTERCARD_1 = require("./SINTERCARD");
-const SINTERSTORE_1 = require("./SINTERSTORE");
-const SISMEMBER_1 = require("./SISMEMBER");
-const SMEMBERS_1 = require("./SMEMBERS");
-const SMISMEMBER_1 = require("./SMISMEMBER");
-const SORT_RO_1 = require("./SORT_RO");
-const SORT_STORE_1 = require("./SORT_STORE");
-const SORT_1 = require("./SORT");
-const SPUBLISH_1 = require("./SPUBLISH");
-const SRANDMEMBER_COUNT_1 = require("./SRANDMEMBER_COUNT");
-const SRANDMEMBER_1 = require("./SRANDMEMBER");
-const SREM_1 = require("./SREM");
-const SSCAN_1 = require("./SSCAN");
-const STRLEN_1 = require("./STRLEN");
-const TOUCH_1 = require("./TOUCH");
-const TTL_1 = require("./TTL");
-const TYPE_1 = require("./TYPE");
-const UNLINK_1 = require("./UNLINK");
-const UNWATCH_1 = require("./UNWATCH");
-const WAIT_1 = require("./WAIT");
-const WATCH_1 = require("./WATCH");
-const XLEN_1 = require("./XLEN");
-const ZADD_1 = require("./ZADD");
-const ZCARD_1 = require("./ZCARD");
-const ZCOUNT_1 = require("./ZCOUNT");
-const ZDIFF_WITHSCORES_1 = require("./ZDIFF_WITHSCORES");
-const ZDIFF_1 = require("./ZDIFF");
-const ZDIFFSTORE_1 = require("./ZDIFFSTORE");
-const ZINCRBY_1 = require("./ZINCRBY");
-const ZINTER_WITHSCORES_1 = require("./ZINTER_WITHSCORES");
-const ZINTER_1 = require("./ZINTER");
-const ZINTERCARD_1 = require("./ZINTERCARD");
-const ZINTERSTORE_1 = require("./ZINTERSTORE");
-const ZLEXCOUNT_1 = require("./ZLEXCOUNT");
-const ZMSCORE_1 = require("./ZMSCORE");
-const ZRANDMEMBER_COUNT_WITHSCORES_1 = require("./ZRANDMEMBER_COUNT_WITHSCORES");
-const ZRANDMEMBER_COUNT_1 = require("./ZRANDMEMBER_COUNT");
-const ZRANDMEMBER_1 = require("./ZRANDMEMBER");
-const ZRANGE_1 = require("./ZRANGE");
-const ZRANK_1 = require("./ZRANK");
-const ZREM_1 = require("./ZREM");
-const ZREVRANK_1 = require("./ZREVRANK");
-const ZSCAN_1 = require("./ZSCAN");
-const ZSCORE_1 = require("./ZSCORE");
+const ACL_CAT_1 = __importDefault(require("./ACL_CAT"));
+const ACL_DELUSER_1 = __importDefault(require("./ACL_DELUSER"));
+const ACL_DRYRUN_1 = __importDefault(require("./ACL_DRYRUN"));
+const ACL_GENPASS_1 = __importDefault(require("./ACL_GENPASS"));
+const ACL_GETUSER_1 = __importDefault(require("./ACL_GETUSER"));
+const ACL_LIST_1 = __importDefault(require("./ACL_LIST"));
+const ACL_LOAD_1 = __importDefault(require("./ACL_LOAD"));
+const ACL_LOG_RESET_1 = __importDefault(require("./ACL_LOG_RESET"));
+const ACL_LOG_1 = __importDefault(require("./ACL_LOG"));
+const ACL_SAVE_1 = __importDefault(require("./ACL_SAVE"));
+const ACL_SETUSER_1 = __importDefault(require("./ACL_SETUSER"));
+const ACL_USERS_1 = __importDefault(require("./ACL_USERS"));
+const ACL_WHOAMI_1 = __importDefault(require("./ACL_WHOAMI"));
+const APPEND_1 = __importDefault(require("./APPEND"));
+const ASKING_1 = __importDefault(require("./ASKING"));
+const AUTH_1 = __importDefault(require("./AUTH"));
+const BGREWRITEAOF_1 = __importDefault(require("./BGREWRITEAOF"));
+const BGSAVE_1 = __importDefault(require("./BGSAVE"));
+const BITCOUNT_1 = __importDefault(require("./BITCOUNT"));
+const BITFIELD_RO_1 = __importDefault(require("./BITFIELD_RO"));
+const BITFIELD_1 = __importDefault(require("./BITFIELD"));
+const BITOP_1 = __importDefault(require("./BITOP"));
+const BITPOS_1 = __importDefault(require("./BITPOS"));
+const BLMOVE_1 = __importDefault(require("./BLMOVE"));
+const BLMPOP_1 = __importDefault(require("./BLMPOP"));
+const BLPOP_1 = __importDefault(require("./BLPOP"));
+const BRPOP_1 = __importDefault(require("./BRPOP"));
+const BRPOPLPUSH_1 = __importDefault(require("./BRPOPLPUSH"));
+const CLIENT_CACHING_1 = __importDefault(require("./CLIENT_CACHING"));
+const CLIENT_GETNAME_1 = __importDefault(require("./CLIENT_GETNAME"));
+const CLIENT_GETREDIR_1 = __importDefault(require("./CLIENT_GETREDIR"));
+const CLIENT_ID_1 = __importDefault(require("./CLIENT_ID"));
+const CLIENT_INFO_1 = __importDefault(require("./CLIENT_INFO"));
+const CLIENT_KILL_1 = __importDefault(require("./CLIENT_KILL"));
+const CLIENT_LIST_1 = __importDefault(require("./CLIENT_LIST"));
+const CLIENT_NO_EVICT_1 = __importDefault(require("./CLIENT_NO-EVICT"));
+const CLIENT_PAUSE_1 = __importDefault(require("./CLIENT_PAUSE"));
+const CLIENT_SETNAME_1 = __importDefault(require("./CLIENT_SETNAME"));
+const CLIENT_TRACKING_1 = __importDefault(require("./CLIENT_TRACKING"));
+const CLIENT_TRACKINGINFO_1 = __importDefault(require("./CLIENT_TRACKINGINFO"));
+const CLIENT_UNPAUSE_1 = __importDefault(require("./CLIENT_UNPAUSE"));
+const CLUSTER_ADDSLOTS_1 = __importDefault(require("./CLUSTER_ADDSLOTS"));
+const CLUSTER_ADDSLOTSRANGE_1 = __importDefault(require("./CLUSTER_ADDSLOTSRANGE"));
+const CLUSTER_BUMPEPOCH_1 = __importDefault(require("./CLUSTER_BUMPEPOCH"));
+const CLUSTER_COUNT_FAILURE_REPORTS_1 = __importDefault(require("./CLUSTER_COUNT-FAILURE-REPORTS"));
+const CLUSTER_COUNTKEYSINSLOT_1 = __importDefault(require("./CLUSTER_COUNTKEYSINSLOT"));
+const CLUSTER_DELSLOTS_1 = __importDefault(require("./CLUSTER_DELSLOTS"));
+const CLUSTER_DELSLOTSRANGE_1 = __importDefault(require("./CLUSTER_DELSLOTSRANGE"));
+const CLUSTER_FAILOVER_1 = __importDefault(require("./CLUSTER_FAILOVER"));
+const CLUSTER_FLUSHSLOTS_1 = __importDefault(require("./CLUSTER_FLUSHSLOTS"));
+const CLUSTER_FORGET_1 = __importDefault(require("./CLUSTER_FORGET"));
+const CLUSTER_GETKEYSINSLOT_1 = __importDefault(require("./CLUSTER_GETKEYSINSLOT"));
+// import CLUSTER_INFO from './CLUSTER_INFO';
+const CLUSTER_KEYSLOT_1 = __importDefault(require("./CLUSTER_KEYSLOT"));
+const CLUSTER_LINKS_1 = __importDefault(require("./CLUSTER_LINKS"));
+const CLUSTER_MEET_1 = __importDefault(require("./CLUSTER_MEET"));
+const CLUSTER_MYID_1 = __importDefault(require("./CLUSTER_MYID"));
+// import CLUSTER_NODES from './CLUSTER_NODES';
+// import CLUSTER_REPLICAS from './CLUSTER_REPLICAS';
+const CLUSTER_REPLICATE_1 = __importDefault(require("./CLUSTER_REPLICATE"));
+const CLUSTER_RESET_1 = __importDefault(require("./CLUSTER_RESET"));
+const CLUSTER_SAVECONFIG_1 = __importDefault(require("./CLUSTER_SAVECONFIG"));
+const CLUSTER_SET_CONFIG_EPOCH_1 = __importDefault(require("./CLUSTER_SET-CONFIG-EPOCH"));
+const CLUSTER_SETSLOT_1 = __importDefault(require("./CLUSTER_SETSLOT"));
+const CLUSTER_SLOTS_1 = __importDefault(require("./CLUSTER_SLOTS"));
+const CONFIG_GET_1 = __importDefault(require("./CONFIG_GET"));
+const CONFIG_RESETSTAT_1 = __importDefault(require("./CONFIG_RESETSTAT"));
+const CONFIG_REWRITE_1 = __importDefault(require("./CONFIG_REWRITE"));
+const CONFIG_SET_1 = __importDefault(require("./CONFIG_SET"));
+const COPY_1 = __importDefault(require("./COPY"));
+const DBSIZE_1 = __importDefault(require("./DBSIZE"));
+const DECR_1 = __importDefault(require("./DECR"));
+const DECRBY_1 = __importDefault(require("./DECRBY"));
+const DEL_1 = __importDefault(require("./DEL"));
+const DUMP_1 = __importDefault(require("./DUMP"));
+const ECHO_1 = __importDefault(require("./ECHO"));
+const EVAL_RO_1 = __importDefault(require("./EVAL_RO"));
+const EVAL_1 = __importDefault(require("./EVAL"));
+const EVALSHA_RO_1 = __importDefault(require("./EVALSHA_RO"));
+const EVALSHA_1 = __importDefault(require("./EVALSHA"));
+const GEOADD_1 = __importDefault(require("./GEOADD"));
+const GEODIST_1 = __importDefault(require("./GEODIST"));
+const GEOHASH_1 = __importDefault(require("./GEOHASH"));
+const GEOPOS_1 = __importDefault(require("./GEOPOS"));
+const GEORADIUS_RO_WITH_1 = __importDefault(require("./GEORADIUS_RO_WITH"));
+const GEORADIUS_RO_1 = __importDefault(require("./GEORADIUS_RO"));
+const GEORADIUS_STORE_1 = __importDefault(require("./GEORADIUS_STORE"));
+const GEORADIUS_WITH_1 = __importDefault(require("./GEORADIUS_WITH"));
+const GEORADIUS_1 = __importDefault(require("./GEORADIUS"));
+const GEORADIUSBYMEMBER_RO_WITH_1 = __importDefault(require("./GEORADIUSBYMEMBER_RO_WITH"));
+const GEORADIUSBYMEMBER_RO_1 = __importDefault(require("./GEORADIUSBYMEMBER_RO"));
+const GEORADIUSBYMEMBER_STORE_1 = __importDefault(require("./GEORADIUSBYMEMBER_STORE"));
+const GEORADIUSBYMEMBER_WITH_1 = __importDefault(require("./GEORADIUSBYMEMBER_WITH"));
+const GEORADIUSBYMEMBER_1 = __importDefault(require("./GEORADIUSBYMEMBER"));
+const GEOSEARCH_WITH_1 = __importDefault(require("./GEOSEARCH_WITH"));
+const GEOSEARCH_1 = __importDefault(require("./GEOSEARCH"));
+const GEOSEARCHSTORE_1 = __importDefault(require("./GEOSEARCHSTORE"));
+const GET_1 = __importDefault(require("./GET"));
+const GETBIT_1 = __importDefault(require("./GETBIT"));
+const GETDEL_1 = __importDefault(require("./GETDEL"));
+const GETEX_1 = __importDefault(require("./GETEX"));
+const GETRANGE_1 = __importDefault(require("./GETRANGE"));
+const GETSET_1 = __importDefault(require("./GETSET"));
+const EXISTS_1 = __importDefault(require("./EXISTS"));
+const EXPIRE_1 = __importDefault(require("./EXPIRE"));
+const EXPIREAT_1 = __importDefault(require("./EXPIREAT"));
+const EXPIRETIME_1 = __importDefault(require("./EXPIRETIME"));
+const FLUSHALL_1 = __importDefault(require("./FLUSHALL"));
+const FLUSHDB_1 = __importDefault(require("./FLUSHDB"));
+const FCALL_1 = __importDefault(require("./FCALL"));
+const FCALL_RO_1 = __importDefault(require("./FCALL_RO"));
+const FUNCTION_DELETE_1 = __importDefault(require("./FUNCTION_DELETE"));
+const FUNCTION_DUMP_1 = __importDefault(require("./FUNCTION_DUMP"));
+const FUNCTION_FLUSH_1 = __importDefault(require("./FUNCTION_FLUSH"));
+const FUNCTION_KILL_1 = __importDefault(require("./FUNCTION_KILL"));
+const FUNCTION_LIST_WITHCODE_1 = __importDefault(require("./FUNCTION_LIST_WITHCODE"));
+const FUNCTION_LIST_1 = __importDefault(require("./FUNCTION_LIST"));
+const FUNCTION_LOAD_1 = __importDefault(require("./FUNCTION_LOAD"));
+const FUNCTION_RESTORE_1 = __importDefault(require("./FUNCTION_RESTORE"));
+// import FUNCTION_STATS from './FUNCTION_STATS';
+const HDEL_1 = __importDefault(require("./HDEL"));
+const HELLO_1 = __importDefault(require("./HELLO"));
+const HEXISTS_1 = __importDefault(require("./HEXISTS"));
+const HGET_1 = __importDefault(require("./HGET"));
+const HGETALL_1 = __importDefault(require("./HGETALL"));
+const HINCRBY_1 = __importDefault(require("./HINCRBY"));
+const HINCRBYFLOAT_1 = __importDefault(require("./HINCRBYFLOAT"));
+const HKEYS_1 = __importDefault(require("./HKEYS"));
+const HLEN_1 = __importDefault(require("./HLEN"));
+const HMGET_1 = __importDefault(require("./HMGET"));
+const HRANDFIELD_COUNT_WITHVALUES_1 = __importDefault(require("./HRANDFIELD_COUNT_WITHVALUES"));
+const HRANDFIELD_COUNT_1 = __importDefault(require("./HRANDFIELD_COUNT"));
+const HRANDFIELD_1 = __importDefault(require("./HRANDFIELD"));
+const HSCAN_1 = __importDefault(require("./HSCAN"));
+const HSET_1 = __importDefault(require("./HSET"));
+const HSETNX_1 = __importDefault(require("./HSETNX"));
+const HSTRLEN_1 = __importDefault(require("./HSTRLEN"));
+const HVALS_1 = __importDefault(require("./HVALS"));
+const INCR_1 = __importDefault(require("./INCR"));
+const INCRBY_1 = __importDefault(require("./INCRBY"));
+const INCRBYFLOAT_1 = __importDefault(require("./INCRBYFLOAT"));
+const INFO_1 = __importDefault(require("./INFO"));
+const KEYS_1 = __importDefault(require("./KEYS"));
+const LASTSAVE_1 = __importDefault(require("./LASTSAVE"));
+const LATENCY_DOCTOR_1 = __importDefault(require("./LATENCY_DOCTOR"));
+const LATENCY_GRAPH_1 = __importDefault(require("./LATENCY_GRAPH"));
+const LATENCY_LATEST_1 = __importDefault(require("./LATENCY_LATEST"));
+const LCS_IDX_WITHMATCHLEN_1 = __importDefault(require("./LCS_IDX_WITHMATCHLEN"));
+const LCS_IDX_1 = __importDefault(require("./LCS_IDX"));
+const LCS_LEN_1 = __importDefault(require("./LCS_LEN"));
+const LCS_1 = __importDefault(require("./LCS"));
+const LINDEX_1 = __importDefault(require("./LINDEX"));
+const LINSERT_1 = __importDefault(require("./LINSERT"));
+const LLEN_1 = __importDefault(require("./LLEN"));
+const LMOVE_1 = __importDefault(require("./LMOVE"));
+const LMPOP_1 = __importDefault(require("./LMPOP"));
+const LOLWUT_1 = __importDefault(require("./LOLWUT"));
+const LPOP_COUNT_1 = __importDefault(require("./LPOP_COUNT"));
+const LPOP_1 = __importDefault(require("./LPOP"));
+const LPOS_COUNT_1 = __importDefault(require("./LPOS_COUNT"));
+const LPOS_1 = __importDefault(require("./LPOS"));
+const LPUSH_1 = __importDefault(require("./LPUSH"));
+const LPUSHX_1 = __importDefault(require("./LPUSHX"));
+const LRANGE_1 = __importDefault(require("./LRANGE"));
+const LREM_1 = __importDefault(require("./LREM"));
+const LSET_1 = __importDefault(require("./LSET"));
+const LTRIM_1 = __importDefault(require("./LTRIM"));
+const MEMORY_DOCTOR_1 = __importDefault(require("./MEMORY_DOCTOR"));
+const MEMORY_MALLOC_STATS_1 = __importDefault(require("./MEMORY_MALLOC-STATS"));
+const MEMORY_PURGE_1 = __importDefault(require("./MEMORY_PURGE"));
+const MEMORY_STATS_1 = __importDefault(require("./MEMORY_STATS"));
+const MEMORY_USAGE_1 = __importDefault(require("./MEMORY_USAGE"));
+const MGET_1 = __importDefault(require("./MGET"));
+const MODULE_LIST_1 = __importDefault(require("./MODULE_LIST"));
+const MODULE_LOAD_1 = __importDefault(require("./MODULE_LOAD"));
+const MODULE_UNLOAD_1 = __importDefault(require("./MODULE_UNLOAD"));
+const MOVE_1 = __importDefault(require("./MOVE"));
+const MSET_1 = __importDefault(require("./MSET"));
+const MSETNX_1 = __importDefault(require("./MSETNX"));
+const OBJECT_ENCODING_1 = __importDefault(require("./OBJECT_ENCODING"));
+const OBJECT_FREQ_1 = __importDefault(require("./OBJECT_FREQ"));
+const OBJECT_IDLETIME_1 = __importDefault(require("./OBJECT_IDLETIME"));
+const OBJECT_REFCOUNT_1 = __importDefault(require("./OBJECT_REFCOUNT"));
+const PERSIST_1 = __importDefault(require("./PERSIST"));
+const PEXPIRE_1 = __importDefault(require("./PEXPIRE"));
+const PEXPIREAT_1 = __importDefault(require("./PEXPIREAT"));
+const PEXPIRETIME_1 = __importDefault(require("./PEXPIRETIME"));
+const PFADD_1 = __importDefault(require("./PFADD"));
+const PFCOUNT_1 = __importDefault(require("./PFCOUNT"));
+const PFMERGE_1 = __importDefault(require("./PFMERGE"));
+const PING_1 = __importDefault(require("./PING"));
+const PSETEX_1 = __importDefault(require("./PSETEX"));
+const PTTL_1 = __importDefault(require("./PTTL"));
+const PUBLISH_1 = __importDefault(require("./PUBLISH"));
+const PUBSUB_CHANNELS_1 = __importDefault(require("./PUBSUB_CHANNELS"));
+const PUBSUB_NUMPAT_1 = __importDefault(require("./PUBSUB_NUMPAT"));
+const PUBSUB_NUMSUB_1 = __importDefault(require("./PUBSUB_NUMSUB"));
+const PUBSUB_SHARDCHANNELS_1 = __importDefault(require("./PUBSUB_SHARDCHANNELS"));
+const RANDOMKEY_1 = __importDefault(require("./RANDOMKEY"));
+const READONLY_1 = __importDefault(require("./READONLY"));
+const RENAME_1 = __importDefault(require("./RENAME"));
+const RENAMENX_1 = __importDefault(require("./RENAMENX"));
+const ROLE_1 = __importDefault(require("./ROLE"));
+const RPOP_COUNT_1 = __importDefault(require("./RPOP_COUNT"));
+const RPOP_1 = __importDefault(require("./RPOP"));
+const RPOPLPUSH_1 = __importDefault(require("./RPOPLPUSH"));
+const RPUSH_1 = __importDefault(require("./RPUSH"));
+const RPUSHX_1 = __importDefault(require("./RPUSHX"));
+const SADD_1 = __importDefault(require("./SADD"));
+const SCAN_1 = __importDefault(require("./SCAN"));
+const SCARD_1 = __importDefault(require("./SCARD"));
+const SCRIPT_DEBUG_1 = __importDefault(require("./SCRIPT_DEBUG"));
+const SCRIPT_EXISTS_1 = __importDefault(require("./SCRIPT_EXISTS"));
+const SCRIPT_FLUSH_1 = __importDefault(require("./SCRIPT_FLUSH"));
+const SCRIPT_KILL_1 = __importDefault(require("./SCRIPT_KILL"));
+const SCRIPT_LOAD_1 = __importDefault(require("./SCRIPT_LOAD"));
+const SDIFF_1 = __importDefault(require("./SDIFF"));
+const SDIFFSTORE_1 = __importDefault(require("./SDIFFSTORE"));
+const SET_1 = __importDefault(require("./SET"));
+const SETBIT_1 = __importDefault(require("./SETBIT"));
+const SETEX_1 = __importDefault(require("./SETEX"));
+const SETNX_1 = __importDefault(require("./SETNX"));
+const SETRANGE_1 = __importDefault(require("./SETRANGE"));
+const SINTER_1 = __importDefault(require("./SINTER"));
+const SINTERCARD_1 = __importDefault(require("./SINTERCARD"));
+const SINTERSTORE_1 = __importDefault(require("./SINTERSTORE"));
+const SISMEMBER_1 = __importDefault(require("./SISMEMBER"));
+const SMEMBERS_1 = __importDefault(require("./SMEMBERS"));
+const SMISMEMBER_1 = __importDefault(require("./SMISMEMBER"));
+const SMOVE_1 = __importDefault(require("./SMOVE"));
+const SORT_RO_1 = __importDefault(require("./SORT_RO"));
+const SORT_STORE_1 = __importDefault(require("./SORT_STORE"));
+const SORT_1 = __importDefault(require("./SORT"));
+const SPOP_COUNT_1 = __importDefault(require("./SPOP_COUNT"));
+const SPOP_1 = __importDefault(require("./SPOP"));
+const SPUBLISH_1 = __importDefault(require("./SPUBLISH"));
+const SRANDMEMBER_COUNT_1 = __importDefault(require("./SRANDMEMBER_COUNT"));
+const SRANDMEMBER_1 = __importDefault(require("./SRANDMEMBER"));
+const SREM_1 = __importDefault(require("./SREM"));
+const SSCAN_1 = __importDefault(require("./SSCAN"));
+const STRLEN_1 = __importDefault(require("./STRLEN"));
+const SUNION_1 = __importDefault(require("./SUNION"));
+const SUNIONSTORE_1 = __importDefault(require("./SUNIONSTORE"));
+const SWAPDB_1 = __importDefault(require("./SWAPDB"));
+const TIME_1 = __importDefault(require("./TIME"));
+const TOUCH_1 = __importDefault(require("./TOUCH"));
+const TTL_1 = __importDefault(require("./TTL"));
+const TYPE_1 = __importDefault(require("./TYPE"));
+const UNLINK_1 = __importDefault(require("./UNLINK"));
+const UNWATCH_1 = __importDefault(require("./UNWATCH"));
+const WAIT_1 = __importDefault(require("./WAIT"));
+const WATCH_1 = __importDefault(require("./WATCH"));
+const XACK_1 = __importDefault(require("./XACK"));
+const XADD_NOMKSTREAM_1 = __importDefault(require("./XADD_NOMKSTREAM"));
+const XADD_1 = __importDefault(require("./XADD"));
+const XDEL_1 = __importDefault(require("./XDEL"));
+const XSETID_1 = __importDefault(require("./XSETID"));
+const XTRIM_1 = __importDefault(require("./XTRIM"));
+const XLEN_1 = __importDefault(require("./XLEN"));
+const ZADD_INCR_1 = __importDefault(require("./ZADD_INCR"));
+const ZADD_1 = __importDefault(require("./ZADD"));
+const ZCARD_1 = __importDefault(require("./ZCARD"));
+const ZCOUNT_1 = __importDefault(require("./ZCOUNT"));
+const ZDIFF_WITHSCORES_1 = __importDefault(require("./ZDIFF_WITHSCORES"));
+const ZDIFF_1 = __importDefault(require("./ZDIFF"));
+const ZDIFFSTORE_1 = __importDefault(require("./ZDIFFSTORE"));
+const ZINCRBY_1 = __importDefault(require("./ZINCRBY"));
+const ZINTER_WITHSCORES_1 = __importDefault(require("./ZINTER_WITHSCORES"));
+const ZINTER_1 = __importDefault(require("./ZINTER"));
+const ZINTERCARD_1 = __importDefault(require("./ZINTERCARD"));
+const ZINTERSTORE_1 = __importDefault(require("./ZINTERSTORE"));
+const ZLEXCOUNT_1 = __importDefault(require("./ZLEXCOUNT"));
+const ZMPOP_1 = __importDefault(require("./ZMPOP"));
+const ZMSCORE_1 = __importDefault(require("./ZMSCORE"));
+const ZPOPMAX_COUNT_1 = __importDefault(require("./ZPOPMAX_COUNT"));
+const ZPOPMAX_1 = __importDefault(require("./ZPOPMAX"));
+const ZPOPMIN_COUNT_1 = __importDefault(require("./ZPOPMIN_COUNT"));
+const ZPOPMIN_1 = __importDefault(require("./ZPOPMIN"));
+const ZRANDMEMBER_COUNT_WITHSCORES_1 = __importDefault(require("./ZRANDMEMBER_COUNT_WITHSCORES"));
+const ZRANDMEMBER_COUNT_1 = __importDefault(require("./ZRANDMEMBER_COUNT"));
+const ZRANDMEMBER_1 = __importDefault(require("./ZRANDMEMBER"));
+const ZRANGE_WITHSCORES_1 = __importDefault(require("./ZRANGE_WITHSCORES"));
+const ZRANGE_1 = __importDefault(require("./ZRANGE"));
+const ZRANGEBYLEX_1 = __importDefault(require("./ZRANGEBYLEX"));
+const ZRANGEBYSCORE_WITHSCORES_1 = __importDefault(require("./ZRANGEBYSCORE_WITHSCORES"));
+const ZRANGEBYSCORE_1 = __importDefault(require("./ZRANGEBYSCORE"));
+const ZRANGESTORE_1 = __importDefault(require("./ZRANGESTORE"));
+const ZREMRANGEBYSCORE_1 = __importDefault(require("./ZREMRANGEBYSCORE"));
+const ZRANK_WITHSCORE_1 = __importDefault(require("./ZRANK_WITHSCORE"));
+const ZRANK_1 = __importDefault(require("./ZRANK"));
+const ZREM_1 = __importDefault(require("./ZREM"));
+const ZREMRANGEBYLEX_1 = __importDefault(require("./ZREMRANGEBYLEX"));
+const ZREMRANGEBYRANK_1 = __importDefault(require("./ZREMRANGEBYRANK"));
+const ZREVRANK_1 = __importDefault(require("./ZREVRANK"));
+const ZSCAN_1 = __importDefault(require("./ZSCAN"));
+const ZSCORE_1 = __importDefault(require("./ZSCORE"));
+const ZUNION_WITHSCORES_1 = __importDefault(require("./ZUNION_WITHSCORES"));
+const ZUNION_1 = __importDefault(require("./ZUNION"));
+const ZUNIONSTORE_1 = __importDefault(require("./ZUNIONSTORE"));
 exports.default = {
     ACL_CAT: ACL_CAT_1.default,
     aclCat: ACL_CAT_1.default,
+    ACL_DELUSER: ACL_DELUSER_1.default,
+    aclDelUser: ACL_DELUSER_1.default,
     ACL_DRYRUN: ACL_DRYRUN_1.default,
@@ -238,6 +382,36 @@ aclDryRun: ACL_DRYRUN_1.default,
     clientSetName: CLIENT_SETNAME_1.default,
+    CLIENT_TRACKING: CLIENT_TRACKING_1.default,
+    clientTracking: CLIENT_TRACKING_1.default,
+    CLIENT_TRACKINGINFO: CLIENT_TRACKINGINFO_1.default,
+    clientTrackingInfo: CLIENT_TRACKINGINFO_1.default,
+    CLIENT_UNPAUSE: CLIENT_UNPAUSE_1.default,
+    clientUnpause: CLIENT_UNPAUSE_1.default,
     CLUSTER_ADDSLOTS: CLUSTER_ADDSLOTS_1.default,
     clusterAddSlots: CLUSTER_ADDSLOTS_1.default,
-    CLUSTER_SLOTS: CLUSTER_SLOTS_1.default,
-    clusterSlots: CLUSTER_SLOTS_1.default,
+    CLUSTER_ADDSLOTSRANGE: CLUSTER_ADDSLOTSRANGE_1.default,
+    clusterAddSlotsRange: CLUSTER_ADDSLOTSRANGE_1.default,
+    CLUSTER_BUMPEPOCH: CLUSTER_BUMPEPOCH_1.default,
+    clusterBumpEpoch: CLUSTER_BUMPEPOCH_1.default,
+    'CLUSTER_COUNT-FAILURE-REPORTS': CLUSTER_COUNT_FAILURE_REPORTS_1.default,
+    clusterCountFailureReports: CLUSTER_COUNT_FAILURE_REPORTS_1.default,
+    CLUSTER_COUNTKEYSINSLOT: CLUSTER_COUNTKEYSINSLOT_1.default,
+    clusterCountKeysInSlot: CLUSTER_COUNTKEYSINSLOT_1.default,
+    CLUSTER_DELSLOTS: CLUSTER_DELSLOTS_1.default,
+    clusterDelSlots: CLUSTER_DELSLOTS_1.default,
+    CLUSTER_DELSLOTSRANGE: CLUSTER_DELSLOTSRANGE_1.default,
+    clusterDelSlotsRange: CLUSTER_DELSLOTSRANGE_1.default,
+    CLUSTER_FAILOVER: CLUSTER_FAILOVER_1.default,
+    clusterFailover: CLUSTER_FAILOVER_1.default,
+    CLUSTER_FLUSHSLOTS: CLUSTER_FLUSHSLOTS_1.default,
+    clusterFlushSlots: CLUSTER_FLUSHSLOTS_1.default,
+    CLUSTER_FORGET: CLUSTER_FORGET_1.default,
+    clusterForget: CLUSTER_FORGET_1.default,
+    CLUSTER_GETKEYSINSLOT: CLUSTER_GETKEYSINSLOT_1.default,
+    clusterGetKeysInSlot: CLUSTER_GETKEYSINSLOT_1.default,
+    // CLUSTER_INFO,
+    // clusterInfo: CLUSTER_INFO,
+    CLUSTER_KEYSLOT: CLUSTER_KEYSLOT_1.default,
+    clusterKeySlot: CLUSTER_KEYSLOT_1.default,
+    CLUSTER_LINKS: CLUSTER_LINKS_1.default,
+    clusterLinks: CLUSTER_LINKS_1.default,
     CLUSTER_MEET: CLUSTER_MEET_1.default,
@@ -247,4 +421,30 @@ clusterMeet: CLUSTER_MEET_1.default,
     clusterMyId: CLUSTER_MYID_1.default,
+    // CLUSTER_NODES,
+    // clusterNodes: CLUSTER_NODES,
+    // CLUSTER_REPLICAS,
+    // clusterReplicas: CLUSTER_REPLICAS,
     CLUSTER_REPLICATE: CLUSTER_REPLICATE_1.default,
     clusterReplicate: CLUSTER_REPLICATE_1.default,
+    CLUSTER_RESET: CLUSTER_RESET_1.default,
+    clusterReset: CLUSTER_RESET_1.default,
+    CLUSTER_SAVECONFIG: CLUSTER_SAVECONFIG_1.default,
+    clusterSaveConfig: CLUSTER_SAVECONFIG_1.default,
+    'CLUSTER_SET-CONFIG-EPOCH': CLUSTER_SET_CONFIG_EPOCH_1.default,
+    clusterSetConfigEpoch: CLUSTER_SET_CONFIG_EPOCH_1.default,
+    CLUSTER_SETSLOT: CLUSTER_SETSLOT_1.default,
+    clusterSetSlot: CLUSTER_SETSLOT_1.default,
+    CLUSTER_SLOTS: CLUSTER_SLOTS_1.default,
+    clusterSlots: CLUSTER_SLOTS_1.default,
+    CONFIG_GET: CONFIG_GET_1.default,
+    configGet: CONFIG_GET_1.default,
+    CONFIG_RESETASTAT: CONFIG_RESETSTAT_1.default,
+    configResetStat: CONFIG_RESETSTAT_1.default,
+    CONFIG_REWRITE: CONFIG_REWRITE_1.default,
+    configRewrite: CONFIG_REWRITE_1.default,
+    CONFIG_SET: CONFIG_SET_1.default,
+    configSet: CONFIG_SET_1.default,
+    COPY: COPY_1.default,
+    copy: COPY_1.default,
+    DBSIZE: DBSIZE_1.default,
+    dbSize: DBSIZE_1.default,
     DECR: DECR_1.default,
@@ -254,4 +454,88 @@ decr: DECR_1.default,
     decrBy: DECRBY_1.default,
+    DEL: DEL_1.default,
+    del: DEL_1.default,
+    DUMP: DUMP_1.default,
+    dump: DUMP_1.default,
+    ECHO: ECHO_1.default,
+    echo: ECHO_1.default,
+    EVAL_RO: EVAL_RO_1.default,
+    evalRo: EVAL_RO_1.default,
+    EVAL: EVAL_1.default,
+    eval: EVAL_1.default,
+    EVALSHA_RO: EVALSHA_RO_1.default,
+    evalShaRo: EVALSHA_RO_1.default,
+    EVALSHA: EVALSHA_1.default,
+    evalSha: EVALSHA_1.default,
+    EXISTS: EXISTS_1.default,
+    exists: EXISTS_1.default,
+    EXPIRE: EXPIRE_1.default,
+    expire: EXPIRE_1.default,
+    EXPIREAT: EXPIREAT_1.default,
+    expireAt: EXPIREAT_1.default,
+    EXPIRETIME: EXPIRETIME_1.default,
+    expireTime: EXPIRETIME_1.default,
+    FLUSHALL: FLUSHALL_1.default,
+    flushAll: FLUSHALL_1.default,
+    FLUSHDB: FLUSHDB_1.default,
+    flushDb: FLUSHDB_1.default,
+    FCALL: FCALL_1.default,
+    fCall: FCALL_1.default,
+    FCALL_RO: FCALL_RO_1.default,
+    fCallRo: FCALL_RO_1.default,
+    FUNCTION_DELETE: FUNCTION_DELETE_1.default,
+    functionDelete: FUNCTION_DELETE_1.default,
+    FUNCTION_DUMP: FUNCTION_DUMP_1.default,
+    functionDump: FUNCTION_DUMP_1.default,
+    FUNCTION_FLUSH: FUNCTION_FLUSH_1.default,
+    functionFlush: FUNCTION_FLUSH_1.default,
+    FUNCTION_KILL: FUNCTION_KILL_1.default,
+    functionKill: FUNCTION_KILL_1.default,
+    FUNCTION_LIST_WITHCODE: FUNCTION_LIST_WITHCODE_1.default,
+    functionListWithCode: FUNCTION_LIST_WITHCODE_1.default,
+    FUNCTION_LIST: FUNCTION_LIST_1.default,
+    functionList: FUNCTION_LIST_1.default,
+    FUNCTION_LOAD: FUNCTION_LOAD_1.default,
+    functionLoad: FUNCTION_LOAD_1.default,
+    FUNCTION_RESTORE: FUNCTION_RESTORE_1.default,
+    functionRestore: FUNCTION_RESTORE_1.default,
+    // FUNCTION_STATS,
+    // functionStats: FUNCTION_STATS,
+    GEOADD: GEOADD_1.default,
+    geoAdd: GEOADD_1.default,
+    GEODIST: GEODIST_1.default,
+    geoDist: GEODIST_1.default,
+    GEOHASH: GEOHASH_1.default,
+    geoHash: GEOHASH_1.default,
+    GEOPOS: GEOPOS_1.default,
+    geoPos: GEOPOS_1.default,
+    GEORADIUS_RO_WITH: GEORADIUS_RO_WITH_1.default,
+    geoRadiusRoWith: GEORADIUS_RO_WITH_1.default,
+    GEORADIUS_RO: GEORADIUS_RO_1.default,
+    geoRadiusRo: GEORADIUS_RO_1.default,
+    GEORADIUS_STORE: GEORADIUS_STORE_1.default,
+    geoRadiusStore: GEORADIUS_STORE_1.default,
+    GEORADIUS_WITH: GEORADIUS_WITH_1.default,
+    geoRadiusWith: GEORADIUS_WITH_1.default,
+    GEORADIUS: GEORADIUS_1.default,
+    geoRadius: GEORADIUS_1.default,
+    GEORADIUSBYMEMBER_RO_WITH: GEORADIUSBYMEMBER_RO_WITH_1.default,
+    geoRadiusByMemberRoWith: GEORADIUSBYMEMBER_RO_WITH_1.default,
+    GEORADIUSBYMEMBER_RO: GEORADIUSBYMEMBER_RO_1.default,
+    geoRadiusByMemberRo: GEORADIUSBYMEMBER_RO_1.default,
+    GEORADIUSBYMEMBER_STORE: GEORADIUSBYMEMBER_STORE_1.default,
+    geoRadiusByMemberStore: GEORADIUSBYMEMBER_STORE_1.default,
+    GEORADIUSBYMEMBER_WITH: GEORADIUSBYMEMBER_WITH_1.default,
+    geoRadiusByMemberWith: GEORADIUSBYMEMBER_WITH_1.default,
+    GEORADIUSBYMEMBER: GEORADIUSBYMEMBER_1.default,
+    geoRadiusByMember: GEORADIUSBYMEMBER_1.default,
+    GEOSEARCH_WITH: GEOSEARCH_WITH_1.default,
+    geoSearchWith: GEOSEARCH_WITH_1.default,
+    GEOSEARCH: GEOSEARCH_1.default,
+    geoSearch: GEOSEARCH_1.default,
+    GEOSEARCHSTORE: GEOSEARCHSTORE_1.default,
+    geoSearchStore: GEOSEARCHSTORE_1.default,
     GET: GET_1.default,
     get: GET_1.default,
+    GETBIT: GETBIT_1.default,
+    getBit: GETBIT_1.default,
     GETDEL: GETDEL_1.default,
@@ -265,6 +549,6 @@ getDel: GETDEL_1.default,
     getSet: GETSET_1.default,
-    FLUSHALL: FLUSHALL_1.default,
-    flushAll: FLUSHALL_1.default,
     HDEL: HDEL_1.default,
     hDel: HDEL_1.default,
+    HELLO: HELLO_1.default,
+    hello: HELLO_1.default,
     HEXISTS: HEXISTS_1.default,
@@ -285,3 +569,3 @@ hExists: HEXISTS_1.default,
     HMGET: HMGET_1.default,
-    hMGet: HMGET_1.default,
+    hmGet: HMGET_1.default,
     HRANDFIELD_COUNT_WITHVALUES: HRANDFIELD_COUNT_WITHVALUES_1.default,
@@ -298,3 +582,3 @@ hRandFieldCountWithValues: HRANDFIELD_COUNT_WITHVALUES_1.default,
     HSETNX: HSETNX_1.default,
-    hSetNx: HSETNX_1.default,
+    hSetNX: HSETNX_1.default,
     HSTRLEN: HSTRLEN_1.default,
@@ -312,4 +596,16 @@ hStrLen: HSTRLEN_1.default,
     info: INFO_1.default,
-    // LCS_IDX_WITHMATCHLEN,
-    // LCS_IDX,
+    KEYS: KEYS_1.default,
+    keys: KEYS_1.default,
+    LASTSAVE: LASTSAVE_1.default,
+    lastSave: LASTSAVE_1.default,
+    LATENCY_DOCTOR: LATENCY_DOCTOR_1.default,
+    latencyDoctor: LATENCY_DOCTOR_1.default,
+    LATENCY_GRAPH: LATENCY_GRAPH_1.default,
+    latencyGraph: LATENCY_GRAPH_1.default,
+    LATENCY_LATEST: LATENCY_LATEST_1.default,
+    latencyLatest: LATENCY_LATEST_1.default,
+    LCS_IDX_WITHMATCHLEN: LCS_IDX_WITHMATCHLEN_1.default,
+    lcsIdxWithMatchLen: LCS_IDX_WITHMATCHLEN_1.default,
+    LCS_IDX: LCS_IDX_1.default,
+    lcsIdx: LCS_IDX_1.default,
     LCS_LEN: LCS_LEN_1.default,
@@ -329,2 +625,3 @@ lcsLen: LCS_LEN_1.default,
     lmPop: LMPOP_1.default,
+    LOLWUT: LOLWUT_1.default,
     LPOP_COUNT: LPOP_COUNT_1.default,
@@ -350,8 +647,42 @@ lPopCount: LPOP_COUNT_1.default,
     lTrim: LTRIM_1.default,
+    MEMORY_DOCTOR: MEMORY_DOCTOR_1.default,
+    memoryDoctor: MEMORY_DOCTOR_1.default,
+    'MEMORY_MALLOC-STATS': MEMORY_MALLOC_STATS_1.default,
+    memoryMallocStats: MEMORY_MALLOC_STATS_1.default,
+    MEMORY_PURGE: MEMORY_PURGE_1.default,
+    memoryPurge: MEMORY_PURGE_1.default,
+    MEMORY_STATS: MEMORY_STATS_1.default,
+    memoryStats: MEMORY_STATS_1.default,
+    MEMORY_USAGE: MEMORY_USAGE_1.default,
+    memoryUsage: MEMORY_USAGE_1.default,
     MGET: MGET_1.default,
     mGet: MGET_1.default,
+    MODULE_LIST: MODULE_LIST_1.default,
+    moduleList: MODULE_LIST_1.default,
+    MODULE_LOAD: MODULE_LOAD_1.default,
+    moduleLoad: MODULE_LOAD_1.default,
+    MODULE_UNLOAD: MODULE_UNLOAD_1.default,
+    moduleUnload: MODULE_UNLOAD_1.default,
+    MOVE: MOVE_1.default,
+    move: MOVE_1.default,
     MSET: MSET_1.default,
     mSet: MSET_1.default,
     MSETNX: MSETNX_1.default,
-    mSetNx: MSETNX_1.default,
+    mSetNX: MSETNX_1.default,
+    OBJECT_ENCODING: OBJECT_ENCODING_1.default,
+    objectEncoding: OBJECT_ENCODING_1.default,
+    OBJECT_FREQ: OBJECT_FREQ_1.default,
+    objectFreq: OBJECT_FREQ_1.default,
+    OBJECT_IDLETIME: OBJECT_IDLETIME_1.default,
+    objectIdleTime: OBJECT_IDLETIME_1.default,
+    OBJECT_REFCOUNT: OBJECT_REFCOUNT_1.default,
+    objectRefCount: OBJECT_REFCOUNT_1.default,
+    PERSIST: PERSIST_1.default,
+    persist: PERSIST_1.default,
+    PEXPIRE: PEXPIRE_1.default,
+    pExpire: PEXPIRE_1.default,
+    PEXPIREAT: PEXPIREAT_1.default,
+    pExpireAt: PEXPIREAT_1.default,
+    PEXPIRETIME: PEXPIRETIME_1.default,
+    pExpireTime: PEXPIRETIME_1.default,
     PFADD: PFADD_1.default,
@@ -370,2 +701,18 @@ pfAdd: PFADD_1.default,
     pSetEx: PSETEX_1.default,
+    PTTL: PTTL_1.default,
+    pTTL: PTTL_1.default,
+    PUBLISH: PUBLISH_1.default,
+    publish: PUBLISH_1.default,
+    PUBSUB_CHANNELS: PUBSUB_CHANNELS_1.default,
+    pubSubChannels: PUBSUB_CHANNELS_1.default,
+    PUBSUB_NUMPAT: PUBSUB_NUMPAT_1.default,
+    pubSubNumPat: PUBSUB_NUMPAT_1.default,
+    PUBSUB_NUMSUB: PUBSUB_NUMSUB_1.default,
+    pubSubNumSub: PUBSUB_NUMSUB_1.default,
+    PUBSUB_SHARDCHANNELS: PUBSUB_SHARDCHANNELS_1.default,
+    pubSubShardChannels: PUBSUB_SHARDCHANNELS_1.default,
+    RANDOMKEY: RANDOMKEY_1.default,
+    randomKey: RANDOMKEY_1.default,
+    READONLY: READONLY_1.default,
+    readonly: READONLY_1.default,
     RENAME: RENAME_1.default,
@@ -377,2 +724,4 @@ rename: RENAME_1.default,
     rPopCount: RPOP_COUNT_1.default,
+    ROLE: ROLE_1.default,
+    role: ROLE_1.default,
     RPOP: RPOP_1.default,
@@ -392,2 +741,12 @@ rPop: RPOP_1.default,
     sCard: SCARD_1.default,
+    SCRIPT_DEBUG: SCRIPT_DEBUG_1.default,
+    scriptDebug: SCRIPT_DEBUG_1.default,
+    SCRIPT_EXISTS: SCRIPT_EXISTS_1.default,
+    scriptExists: SCRIPT_EXISTS_1.default,
+    SCRIPT_FLUSH: SCRIPT_FLUSH_1.default,
+    scriptFlush: SCRIPT_FLUSH_1.default,
+    SCRIPT_KILL: SCRIPT_KILL_1.default,
+    scriptKill: SCRIPT_KILL_1.default,
+    SCRIPT_LOAD: SCRIPT_LOAD_1.default,
+    scriptLoad: SCRIPT_LOAD_1.default,
     SDIFF: SDIFF_1.default,
@@ -419,2 +778,4 @@ sDiff: SDIFF_1.default,
     smIsMember: SMISMEMBER_1.default,
+    SMOVE: SMOVE_1.default,
+    sMove: SMOVE_1.default,
     SORT_RO: SORT_RO_1.default,
@@ -426,2 +787,6 @@ sortRo: SORT_RO_1.default,
     sort: SORT_1.default,
+    SPOP_COUNT: SPOP_COUNT_1.default,
+    sPopCount: SPOP_COUNT_1.default,
+    SPOP: SPOP_1.default,
+    sPop: SPOP_1.default,
     SPUBLISH: SPUBLISH_1.default,
@@ -439,2 +804,10 @@ sPublish: SPUBLISH_1.default,
     strLen: STRLEN_1.default,
+    SUNION: SUNION_1.default,
+    sUnion: SUNION_1.default,
+    SUNIONSTORE: SUNIONSTORE_1.default,
+    sUnionStore: SUNIONSTORE_1.default,
+    SWAPDB: SWAPDB_1.default,
+    swapDb: SWAPDB_1.default,
+    TIME: TIME_1.default,
+    time: TIME_1.default,
     TOUCH: TOUCH_1.default,
@@ -454,4 +827,18 @@ touch: TOUCH_1.default,
     watch: WATCH_1.default,
+    XACK: XACK_1.default,
+    xAck: XACK_1.default,
+    XADD_NOMKSTREAM: XADD_NOMKSTREAM_1.default,
+    xAddNoMkStream: XADD_NOMKSTREAM_1.default,
+    XADD: XADD_1.default,
+    xAdd: XADD_1.default,
+    XDEL: XDEL_1.default,
+    xDel: XDEL_1.default,
+    XSETID: XSETID_1.default,
+    xSetId: XSETID_1.default,
+    XTRIM: XTRIM_1.default,
+    xTrim: XTRIM_1.default,
     XLEN: XLEN_1.default,
     xLen: XLEN_1.default,
+    ZADD_INCR: ZADD_INCR_1.default,
+    zAddIncr: ZADD_INCR_1.default,
     ZADD: ZADD_1.default,
@@ -481,4 +868,14 @@ zAdd: ZADD_1.default,
     zLexCount: ZLEXCOUNT_1.default,
+    ZMPOP: ZMPOP_1.default,
+    zmPop: ZMPOP_1.default,
     ZMSCORE: ZMSCORE_1.default,
     zmScore: ZMSCORE_1.default,
+    ZPOPMAX_COUNT: ZPOPMAX_COUNT_1.default,
+    zPopMaxCount: ZPOPMAX_COUNT_1.default,
+    ZPOPMAX: ZPOPMAX_1.default,
+    zPopMax: ZPOPMAX_1.default,
+    ZPOPMIN_COUNT: ZPOPMIN_COUNT_1.default,
+    zPopMinCount: ZPOPMIN_COUNT_1.default,
+    ZPOPMIN: ZPOPMIN_1.default,
+    zPopMin: ZPOPMIN_1.default,
     ZRANDMEMBER_COUNT_WITHSCORES: ZRANDMEMBER_COUNT_WITHSCORES_1.default,
@@ -490,4 +887,16 @@ zRandMemberCountWithScores: ZRANDMEMBER_COUNT_WITHSCORES_1.default,
     zRandMember: ZRANDMEMBER_1.default,
+    ZRANGE_WITHSCORES: ZRANGE_WITHSCORES_1.default,
+    zRangeWithScores: ZRANGE_WITHSCORES_1.default,
     ZRANGE: ZRANGE_1.default,
     zRange: ZRANGE_1.default,
+    ZRANGEBYLEX: ZRANGEBYLEX_1.default,
+    zRangeByLex: ZRANGEBYLEX_1.default,
+    ZRANGEBYSCORE_WITHSCORES: ZRANGEBYSCORE_WITHSCORES_1.default,
+    zRangeByScoreWithScores: ZRANGEBYSCORE_WITHSCORES_1.default,
+    ZRANGEBYSCORE: ZRANGEBYSCORE_1.default,
+    zRangeByScore: ZRANGEBYSCORE_1.default,
+    ZRANGESTORE: ZRANGESTORE_1.default,
+    zRangeStore: ZRANGESTORE_1.default,
+    ZRANK_WITHSCORE: ZRANK_WITHSCORE_1.default,
+    zRankWithScore: ZRANK_WITHSCORE_1.default,
     ZRANK: ZRANK_1.default,
@@ -497,2 +906,8 @@ zRank: ZRANK_1.default,
     zRem: ZREM_1.default,
+    ZREMRANGEBYLEX: ZREMRANGEBYLEX_1.default,
+    zRemRangeByLex: ZREMRANGEBYLEX_1.default,
+    ZREMRANGEBYRANK: ZREMRANGEBYRANK_1.default,
+    zRemRangeByRank: ZREMRANGEBYRANK_1.default,
+    ZREMRANGEBYSCORE: ZREMRANGEBYSCORE_1.default,
+    zRemRangeByScore: ZREMRANGEBYSCORE_1.default,
     ZREVRANK: ZREVRANK_1.default,
@@ -503,3 +918,9 @@ zRevRank: ZREVRANK_1.default,
     ZSCORE: ZSCORE_1.default,
-    zScore: ZSCORE_1.default
+    zScore: ZSCORE_1.default,
+    ZUNION_WITHSCORES: ZUNION_WITHSCORES_1.default,
+    zUnionWithScores: ZUNION_WITHSCORES_1.default,
+    ZUNION: ZUNION_1.default,
+    zUnion: ZUNION_1.default,
+    ZUNIONSTORE: ZUNIONSTORE_1.default,
+    zUnionStore: ZUNIONSTORE_1.default
 };

dist/lib/commands/INFO.d.ts

 import { RedisArgument, VerbatimStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, section?: RedisArgument) => RedisArgument[];

dist/lib/commands/INFO.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(section) {

dist/lib/commands/KEYS.d.ts

 import { RedisArgument, ArrayReply, BlobStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, pattern: RedisArgument) => RedisArgument[];

dist/lib/commands/KEYS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(pattern) {

dist/lib/commands/LASTSAVE.d.ts

@@ -1,3 +0,8 @@
-export declare const IS_READ_ONLY = true;
-export declare function transformArguments(): Array<string>;
-export declare function transformReply(reply: number): Date;
+import { NumberReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: () => NumberReply;
+};
+export default _default;

dist/lib/commands/LASTSAVE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReply = exports.transformArguments = exports.IS_READ_ONLY = void 0;
-exports.IS_READ_ONLY = true;
-function transformArguments() {
-    return ['LASTSAVE'];
-}
-exports.transformArguments = transformArguments;
-function transformReply(reply) {
-    return new Date(reply);
-}
-exports.transformReply = transformReply;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['LASTSAVE'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/LATENCY_DOCTOR.d.ts

@@ -1,2 +0,8 @@
-export declare function transformArguments(): Array<string>;
-export declare function transformReply(): string;
+import { BlobStringReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: () => BlobStringReply;
+};
+export default _default;

dist/lib/commands/LATENCY_DOCTOR.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments() {
-    return ['LATENCY', 'DOCTOR'];
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['LATENCY', 'DOCTOR'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/LATENCY_GRAPH.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// export type EventType =
-//     'active-defrag-cycle'
-//     | 'aof-fsync-always'
-//     | 'aof-stat'
-//     | 'aof-rewrite-diff-write'
-//     | 'aof-rename'
-//     | 'aof-write'
-//     | 'aof-write-active-child'
-//     | 'aof-write-alone'
-//     | 'aof-write-pending-fsync'
-//     | 'command'
-//     | 'expire-cycle'
-//     | 'eviction-cycle'
-//     | 'eviction-del'
-//     | 'fast-command'
-//     | 'fork'
-//     | 'rdb-unlink-temp-file';
-// export function transformArguments(event: EventType): RedisCommandArguments {
-//     return ['LATENCY', 'GRAPH', event];
-// }
-// export declare function transformReply(): string;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LATENCY_EVENTS = void 0;
+exports.LATENCY_EVENTS = {
+    ACTIVE_DEFRAG_CYCLE: 'active-defrag-cycle',
+    AOF_FSYNC_ALWAYS: 'aof-fsync-always',
+    AOF_STAT: 'aof-stat',
+    AOF_REWRITE_DIFF_WRITE: 'aof-rewrite-diff-write',
+    AOF_RENAME: 'aof-rename',
+    AOF_WRITE: 'aof-write',
+    AOF_WRITE_ACTIVE_CHILD: 'aof-write-active-child',
+    AOF_WRITE_ALONE: 'aof-write-alone',
+    AOF_WRITE_PENDING_FSYNC: 'aof-write-pending-fsync',
+    COMMAND: 'command',
+    EXPIRE_CYCLE: 'expire-cycle',
+    EVICTION_CYCLE: 'eviction-cycle',
+    EVICTION_DEL: 'eviction-del',
+    FAST_COMMAND: 'fast-command',
+    FORK: 'fork',
+    RDB_UNLINK_TEMP_FILE: 'rdb-unlink-temp-file'
+};
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments(event) {
+        return ['LATENCY', 'GRAPH', event];
+    },
+    transformReply: undefined
+};

dist/lib/commands/LCS_IDX_WITHMATCHLEN.js

 "use strict";
-// import { RedisArgument, TuplesToMapReply, BlobStringReply, ArrayReply, NumberReply, Resp2Reply, Command, TuplesReply } from '../RESP/types';
-// import LCS from './LCS';
-// import { LcsIdxRange } from './LCS_IDX';
-// interface LcsIdxOptions {
-//   MINMATCHLEN?: number;
-// }
-// export type LcsIdxWithMatchLenMatches = ArrayReply<
-//   TuplesReply<[
-//     key1: LcsIdxRange,
-//     key2: LcsIdxRange,
-//     len: NumberReply
-//   ]>
-// >;
-// export type LcsIdxReply = TuplesToMapReply<[
-//   [BlobStringReply<'matches'>, LcsIdxWithMatchLenMatches],
-//   [BlobStringReply<'len'>, NumberReply]
-// ]>;
-// export default {
-//   FIRST_KEY_INDEX: LCS.FIRST_KEY_INDEX,
-//   IS_READ_ONLY: LCS.IS_READ_ONLY,
-//   transformArguments(
-//     key1: RedisArgument,
-//     key2: RedisArgument,
-//     options?: LcsIdxOptions
-//   ) {
-//     const args = LCS.transformArguments(key1, key2);
-//     if (options?.MINMATCHLEN) {
-//       args.push('MINMATCHLEN', options.MINMATCHLEN.toString());
-//     }
-//     args.push('WITHMATCHLEN');
-//     return args;
-//   },
-//   transformReply: {
-//     2: (reply: Resp2Reply<LcsIdxReply>) => ({
-//       matches: reply[1],
-//       len: reply[2]
-//     }),
-//     3: undefined as unknown as () => LcsIdxReply
-//   }
-// } as const satisfies Command;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LCS_IDX_1 = __importDefault(require("./LCS_IDX"));
+exports.default = {
+    FIRST_KEY_INDEX: LCS_IDX_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: LCS_IDX_1.default.IS_READ_ONLY,
+    transformArguments(key1, key2, options) {
+        const args = LCS_IDX_1.default.transformArguments(key1, key2);
+        args.push('WITHMATCHLEN');
+        return args;
+    },
+    transformReply: {
+        2: (reply) => ({
+            matches: reply[1],
+            len: reply[3]
+        }),
+        3: undefined
+    }
+};

dist/lib/commands/LCS_IDX.js

 "use strict";
-// import { RedisArgument, TuplesToMapReply, BlobStringReply, ArrayReply, NumberReply, Resp2Reply, Command, TuplesReply } from '../RESP/types';
-// import LCS from './LCS';
-// export interface LcsIdxOptions {
-//   MINMATCHLEN?: number;
-// }
-// export type LcsIdxRange = TuplesReply<[
-//   start: NumberReply,
-//   end: NumberReply
-// ]>;
-// export type LcsIdxMatches = ArrayReply<
-//   TuplesReply<[
-//     key1: LcsIdxRange,
-//     key2: LcsIdxRange
-//   ]>
-// >;
-// export type LcsIdxReply = TuplesToMapReply<[
-//   [BlobStringReply<'matches'>, LcsIdxMatches],
-//   [BlobStringReply<'len'>, NumberReply]
-// ]>;
-// export default {
-//   FIRST_KEY_INDEX: LCS.FIRST_KEY_INDEX,
-//   IS_READ_ONLY: LCS.IS_READ_ONLY,
-//   transformArguments(
-//     key1: RedisArgument,
-//     key2: RedisArgument,
-//     options?: LcsIdxOptions
-//   ) {
-//     const args = LCS.transformArguments(key1, key2);
-//     if (options?.MINMATCHLEN) {
-//       args.push('MINMATCHLEN', options.MINMATCHLEN.toString());
-//     }
-//     return args;
-//   },
-//   transformReply: {
-//     2: (reply: Resp2Reply<LcsIdxReply>) => ({
-//       matches: reply[1],
-//       len: reply[2]
-//     }),
-//     3: undefined as unknown as () => LcsIdxReply
-//   }
-// } as const satisfies Command;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const LCS_1 = __importDefault(require("./LCS"));
+exports.default = {
+    FIRST_KEY_INDEX: LCS_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: LCS_1.default.IS_READ_ONLY,
+    transformArguments(key1, key2, options) {
+        const args = LCS_1.default.transformArguments(key1, key2);
+        args.push('IDX');
+        if (options?.MINMATCHLEN) {
+            args.push('MINMATCHLEN', options.MINMATCHLEN.toString());
+        }
+        return args;
+    },
+    transformReply: {
+        2: (reply) => ({
+            matches: reply[1],
+            len: reply[3]
+        }),
+        3: undefined
+    }
+};

dist/lib/commands/LCS_LEN.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const LCS_1 = require("./LCS");
+const LCS_1 = __importDefault(require("./LCS"));
 exports.default = {
@@ -5,0 +8,0 @@ FIRST_KEY_INDEX: LCS_1.default.FIRST_KEY_INDEX,

dist/lib/commands/LMOVE.d.ts

@@ -6,2 +6,3 @@ /// <reference types="node" />
     readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: false;
     readonly transformArguments: (this: void, source: RedisArgument, destination: RedisArgument, sourceSide: ListSide, destinationSide: ListSide) => (string | Buffer)[];
@@ -8,0 +9,0 @@ readonly transformReply: () => BlobStringReply | NullReply;

dist/lib/commands/LMOVE.js

@@ -5,2 +5,3 @@ "use strict";
     FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
     transformArguments(source, destination, sourceSide, destinationSide) {
@@ -7,0 +8,0 @@ return [

dist/lib/commands/LMPOP.d.ts

@@ -1,6 +0,11 @@
-import { NullReply, TuplesReply, BlobStringReply } from '../RESP/types';
-import { LMPopOptions, ListSide, RedisVariadicArgument } from './generic-transformers';
+import { CommandArguments, NullReply, TuplesReply, BlobStringReply } from '../RESP/types';
+import { ListSide, RedisVariadicArgument } from './generic-transformers';
+export interface LMPopOptions {
+    COUNT?: number;
+}
+export declare function transformLMPopArguments(args: CommandArguments, keys: RedisVariadicArgument, side: ListSide, options?: LMPopOptions): CommandArguments;
 declare const _default: {
     readonly FIRST_KEY_INDEX: 2;
-    readonly transformArguments: (this: void, keys: RedisVariadicArgument, side: ListSide, options?: LMPopOptions) => import("../RESP/types").CommandArguments;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, keys: RedisVariadicArgument, side: ListSide, options?: LMPopOptions) => CommandArguments;
     readonly transformReply: () => NullReply | TuplesReply<[
@@ -7,0 +12,0 @@ key: BlobStringReply,

dist/lib/commands/LMPOP.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformLMPopArguments = void 0;
 const generic_transformers_1 = require("./generic-transformers");
+function transformLMPopArguments(args, keys, side, options) {
+    (0, generic_transformers_1.pushVariadicArgument)(args, keys);
+    args.push(side);
+    if (options?.COUNT) {
+        args.push('COUNT', options.COUNT.toString());
+    }
+    return args;
+}
+exports.transformLMPopArguments = transformLMPopArguments;
 exports.default = {
     FIRST_KEY_INDEX: 2,
+    IS_READ_ONLY: false,
     transformArguments(keys, side, options) {
-        return (0, generic_transformers_1.transformLMPopArguments)(['LMPOP'], keys, side, options);
+        return transformLMPopArguments(['LMPOP'], keys, side, options);
     },
     transformReply: undefined
 };

dist/lib/commands/LPOS_COUNT.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const LPOS_1 = require("./LPOS");
+const LPOS_1 = __importDefault(require("./LPOS"));
 exports.default = {
@@ -5,0 +8,0 @@ FIRST_KEY_INDEX: LPOS_1.default.FIRST_KEY_INDEX,

dist/lib/commands/LSET.d.ts

@@ -6,4 +6,4 @@ import { RedisArgument, SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void, key: RedisArgument, index: number, element: RedisArgument) => RedisArgument[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/LSET.js

@@ -8,3 +8,3 @@ "use strict";
         return [
-            'LREM',
+            'LSET',
             key,
@@ -11,0 +11,0 @@ index.toString(),

dist/lib/commands/LTRIM.d.ts

@@ -5,4 +5,4 @@ import { RedisArgument, SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void, key: RedisArgument, start: number, stop: number) => RedisArgument[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/LTRIM.js

@@ -7,3 +7,3 @@ "use strict";
         return [
-            'LREM',
+            'LTRIM',
             key,
@@ -10,0 +10,0 @@ start.toString(),

dist/lib/commands/MEMORY_DOCTOR.d.ts

@@ -1,2 +0,8 @@
-export declare function transformArguments(): Array<string>;
-export declare function transformReply(): string;
+import { BlobStringReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: () => BlobStringReply;
+};
+export default _default;

dist/lib/commands/MEMORY_DOCTOR.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments() {
-    return ['MEMORY', 'DOCTOR'];
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['MEMORY', 'DOCTOR'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/MEMORY_MALLOC-STATS.d.ts

@@ -1,2 +0,8 @@
-export declare function transformArguments(): Array<string>;
-export declare function transformReply(): string;
+import { BlobStringReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: () => BlobStringReply;
+};
+export default _default;

dist/lib/commands/MEMORY_MALLOC-STATS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments() {
-    return ['MEMORY', 'MALLOC-STATS'];
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['MEMORY', 'MALLOC-STATS'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/MEMORY_PURGE.d.ts

@@ -1,2 +0,8 @@
-export declare function transformArguments(): Array<string>;
-export declare function transformReply(): string;
+import { SimpleStringReply } from '../RESP/types';
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: () => SimpleStringReply<'OK'>;
+};
+export default _default;

dist/lib/commands/MEMORY_PURGE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = void 0;
-function transformArguments() {
-    return ['MEMORY', 'PURGE'];
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments() {
+        return ['MEMORY', 'PURGE'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/MEMORY_STATS.d.ts

@@ -1,36 +0,149 @@
-export declare function transformArguments(): Array<string>;
-interface MemoryStatsReply {
-    peakAllocated: number;
-    totalAllocated: number;
-    startupAllocated: number;
-    replicationBacklog: number;
-    clientsReplicas: number;
-    clientsNormal: number;
-    aofBuffer: number;
-    luaCaches: number;
-    overheadTotal: number;
-    keysCount: number;
-    keysBytesPerKey: number;
-    datasetBytes: number;
-    datasetPercentage: number;
-    peakPercentage: number;
-    allocatorAllocated?: number;
-    allocatorActive?: number;
-    allocatorResident?: number;
-    allocatorFragmentationRatio?: number;
-    allocatorFragmentationBytes?: number;
-    allocatorRssRatio?: number;
-    allocatorRssBytes?: number;
-    rssOverheadRatio?: number;
-    rssOverheadBytes?: number;
-    fragmentation?: number;
-    fragmentationBytes: number;
-    db: {
-        [key: number]: {
-            overheadHashtableMain: number;
-            overheadHashtableExpires: number;
+import { TuplesToMapReply, BlobStringReply, NumberReply, DoubleReply } from '../RESP/types';
+export type MemoryStatsReply = TuplesToMapReply<[
+    [
+        BlobStringReply<'peak.allocated'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'total.allocated'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'startup.allocated'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'replication.backlog'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'clients.slaves'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'clients.normal'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'cluster.links'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'aof.buffer'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'lua.caches'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'functions.caches'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'overhead.total'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'keys.count'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'keys.bytes-per-key'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'dataset.bytes'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'dataset.percentage'>,
+        DoubleReply
+    ],
+    [
+        BlobStringReply<'peak.percentage'>,
+        DoubleReply
+    ],
+    [
+        BlobStringReply<'allocator.allocated'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'allocator.active'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'allocator.resident'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'allocator-fragmentation.ratio'>,
+        DoubleReply
+    ],
+    [
+        BlobStringReply<'allocator-fragmentation.bytes'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'allocator-rss.ratio'>,
+        DoubleReply
+    ],
+    [
+        BlobStringReply<'allocator-rss.bytes'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'rss-overhead.ratio'>,
+        DoubleReply
+    ],
+    [
+        BlobStringReply<'rss-overhead.bytes'>,
+        NumberReply
+    ],
+    [
+        BlobStringReply<'fragmentation'>,
+        DoubleReply
+    ],
+    [
+        BlobStringReply<'fragmentation.bytes'>,
+        NumberReply
+    ]
+]>;
+declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void) => string[];
+    readonly transformReply: {
+        readonly 2: (rawReply: Array<BlobStringReply | NumberReply>) => {
+            "peak.allocated": NumberReply;
+            "total.allocated": NumberReply;
+            "startup.allocated": NumberReply;
+            "replication.backlog": NumberReply;
+            "clients.slaves": NumberReply;
+            "clients.normal": NumberReply;
+            "cluster.links": NumberReply;
+            "aof.buffer": NumberReply;
+            "lua.caches": NumberReply;
+            "functions.caches": NumberReply;
+            "overhead.total": NumberReply;
+            "keys.count": NumberReply;
+            "keys.bytes-per-key": NumberReply;
+            "dataset.bytes": NumberReply;
+            "dataset.percentage": DoubleReply;
+            "peak.percentage": DoubleReply;
+            "allocator.allocated": NumberReply;
+            "allocator.active": NumberReply;
+            "allocator.resident": NumberReply;
+            "allocator-fragmentation.ratio": DoubleReply;
+            "allocator-fragmentation.bytes": NumberReply;
+            "allocator-rss.ratio": DoubleReply;
+            "allocator-rss.bytes": NumberReply;
+            "rss-overhead.ratio": DoubleReply;
+            "rss-overhead.bytes": NumberReply;
+            fragmentation: DoubleReply;
+            "fragmentation.bytes": NumberReply;
         };
+        readonly 3: () => MemoryStatsReply;
     };
-}
-export declare function transformReply(rawReply: Array<string | number | Array<string | number>>): MemoryStatsReply;
-export {};
+};
+export default _default;

dist/lib/commands/MEMORY_STATS.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReply = exports.transformArguments = void 0;
-function transformArguments() {
-    return ['MEMORY', 'STATS'];
-}
-exports.transformArguments = transformArguments;
-const FIELDS_MAPPING = {
-    'peak.allocated': 'peakAllocated',
-    'total.allocated': 'totalAllocated',
-    'startup.allocated': 'startupAllocated',
-    'replication.backlog': 'replicationBacklog',
-    'clients.slaves': 'clientsReplicas',
-    'clients.normal': 'clientsNormal',
-    'aof.buffer': 'aofBuffer',
-    'lua.caches': 'luaCaches',
-    'overhead.total': 'overheadTotal',
-    'keys.count': 'keysCount',
-    'keys.bytes-per-key': 'keysBytesPerKey',
-    'dataset.bytes': 'datasetBytes',
-    'dataset.percentage': 'datasetPercentage',
-    'peak.percentage': 'peakPercentage',
-    'allocator.allocated': 'allocatorAllocated',
-    'allocator.active': 'allocatorActive',
-    'allocator.resident': 'allocatorResident',
-    'allocator-fragmentation.ratio': 'allocatorFragmentationRatio',
-    'allocator-fragmentation.bytes': 'allocatorFragmentationBytes',
-    'allocator-rss.ratio': 'allocatorRssRatio',
-    'allocator-rss.bytes': 'allocatorRssBytes',
-    'rss-overhead.ratio': 'rssOverheadRatio',
-    'rss-overhead.bytes': 'rssOverheadBytes',
-    'fragmentation': 'fragmentation',
-    'fragmentation.bytes': 'fragmentationBytes'
-}, DB_FIELDS_MAPPING = {
-    'overhead.hashtable.main': 'overheadHashtableMain',
-    'overhead.hashtable.expires': 'overheadHashtableExpires'
-};
-function transformReply(rawReply) {
-    const reply = {
-        db: {}
-    };
-    for (let i = 0; i < rawReply.length; i += 2) {
-        const key = rawReply[i];
-        if (key.startsWith('db.')) {
-            const dbTuples = rawReply[i + 1], db = {};
-            for (let j = 0; j < dbTuples.length; j += 2) {
-                db[DB_FIELDS_MAPPING[dbTuples[j]]] = dbTuples[j + 1];
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['MEMORY', 'STATS'];
+    },
+    transformReply: {
+        2: (rawReply) => {
+            const reply = {};
+            let i = 0;
+            while (i < rawReply.length) {
+                const key = rawReply[i++];
+                reply[key] = rawReply[i++];
             }
-            reply.db[key.substring(3)] = db;
-            continue;
-        }
-        reply[FIELDS_MAPPING[key]] = Number(rawReply[i + 1]);
+            return reply;
+        },
+        3: undefined
     }
-    return reply;
-}
-exports.transformReply = transformReply;
+};

dist/lib/commands/MEMORY_USAGE.d.ts

@@ -1,8 +0,11 @@
-export declare const FIRST_KEY_INDEX = 1;
-export declare const IS_READ_ONLY = true;
-interface MemoryUsageOptions {
+import { NumberReply, NullReply, RedisArgument } from '../RESP/types';
+export interface MemoryUsageOptions {
     SAMPLES?: number;
 }
-export declare function transformArguments(key: string, options?: MemoryUsageOptions): Array<string>;
-export declare function transformReply(): number | null;
-export {};
+declare const _default: {
+    readonly FIRST_KEY_INDEX: 1;
+    readonly IS_READ_ONLY: true;
+    readonly transformArguments: (this: void, key: RedisArgument, options?: MemoryUsageOptions) => RedisArgument[];
+    readonly transformReply: () => NumberReply | NullReply;
+};
+export default _default;

dist/lib/commands/MEMORY_USAGE.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformArguments = exports.IS_READ_ONLY = exports.FIRST_KEY_INDEX = void 0;
-exports.FIRST_KEY_INDEX = 1;
-exports.IS_READ_ONLY = true;
-function transformArguments(key, options) {
-    const args = ['MEMORY', 'USAGE', key];
-    if (options?.SAMPLES) {
-        args.push('SAMPLES', options.SAMPLES.toString());
-    }
-    return args;
-}
-exports.transformArguments = transformArguments;
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: true,
+    transformArguments(key, options) {
+        const args = ['MEMORY', 'USAGE', key];
+        if (options?.SAMPLES) {
+            args.push('SAMPLES', options.SAMPLES.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/MODULE_LIST.d.ts

@@ -1,2 +0,1 @@
-/// <reference types="node" />
 import { ArrayReply, BlobStringReply, NumberReply, Resp2Reply, TuplesToMapReply } from '../RESP/types';
@@ -9,3 +8,3 @@ export type ModuleListReply = ArrayReply<TuplesToMapReply<[
     [
-        BlobStringReply<'version'>,
+        BlobStringReply<'ver'>,
         NumberReply
@@ -20,14 +19,4 @@ ]
         readonly 2: (reply: Resp2Reply<ModuleListReply>) => {
-            name: (string | Buffer) & {
-                RESP_TYPE: 36;
-                DEFAULT: string;
-                TYPES: Buffer;
-                FLAG: import("../RESP/types").Flag<string | Buffer>;
-            };
-            version: (number | `${number}`) & {
-                RESP_TYPE: 58;
-                DEFAULT: number;
-                TYPES: `${number}`;
-                FLAG: import("../RESP/types").Flag<number | `${number}`>;
-            };
+            name: BlobStringReply;
+            ver: NumberReply;
         }[];
@@ -34,0 +23,0 @@ readonly 3: () => ModuleListReply;

dist/lib/commands/MODULE_LIST.js

@@ -13,3 +13,3 @@ "use strict";
                 name: module[1],
-                version: module[3]
+                ver: module[3]
             }));
@@ -16,0 +16,0 @@ },

dist/lib/commands/MODULE_LOAD.d.ts

@@ -6,4 +6,4 @@ import { RedisArgument, SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void, path: RedisArgument, moduleArguments?: Array<RedisArgument>) => RedisArgument[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/MODULE_UNLOAD.d.ts

@@ -6,4 +6,4 @@ import { RedisArgument, SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void, name: RedisArgument) => RedisArgument[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/PEXPIRETIME.js

@@ -7,5 +7,5 @@ "use strict";
     transformArguments(key) {
-        return ['PEXPIREAT', key];
+        return ['PEXPIRETIME', key];
     },
     transformReply: undefined
 };

dist/lib/commands/PFADD.d.ts

@@ -1,2 +0,2 @@
-import { RedisArgument, ArrayReply, BlobStringReply } from '../RESP/types';
+import { RedisArgument, NumberReply } from '../RESP/types';
 import { RedisVariadicArgument } from './generic-transformers';
@@ -7,4 +7,4 @@ declare const _default: {
     readonly transformArguments: (this: void, key: RedisArgument, element?: RedisVariadicArgument) => RedisArgument[];
-    readonly transformReply: () => ArrayReply<BlobStringReply>;
+    readonly transformReply: () => NumberReply;
 };
 export default _default;

dist/lib/commands/PING.d.ts

 import { RedisArgument, SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, message?: RedisArgument) => RedisArgument[];

dist/lib/commands/PING.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(message) {

dist/lib/commands/PUBSUB_SHARDCHANNELS.js

@@ -7,3 +7,3 @@ "use strict";
     transformArguments(pattern) {
-        const args = ['PUBSUB', 'bb'];
+        const args = ['PUBSUB', 'SHARDCHANNELS'];
         if (pattern) {
@@ -10,0 +10,0 @@ args.push(pattern);

dist/lib/commands/RANDOMKEY.d.ts

 import { NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void) => string[];

dist/lib/commands/RANDOMKEY.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments() {

dist/lib/commands/RENAME.d.ts

 import { RedisArgument, SimpleStringReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, key: RedisArgument, newKey: RedisArgument) => RedisArgument[];

dist/lib/commands/RENAME.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(key, newKey) {

dist/lib/commands/RENAMENX.d.ts

 import { RedisArgument, NumberReply } from '../RESP/types';
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -4,0 +5,0 @@ readonly transformArguments: (this: void, key: RedisArgument, newKey: RedisArgument) => RedisArgument[];

dist/lib/commands/RENAMENX.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -5,0 +6,0 @@ transformArguments(key, newKey) {

dist/lib/commands/ROLE.d.ts

@@ -5,3 +5,3 @@ import { ArrayReply, BlobStringReply, NumberReply } from '../RESP/types';
     replicationOffest: NumberReply,
-    replicas: ArrayReply<[host: BlobStringReply, port: NumberReply, replicationOffest: NumberReply]>
+    replicas: ArrayReply<[host: BlobStringReply, port: BlobStringReply, replicationOffest: BlobStringReply]>
 ];
@@ -29,4 +29,4 @@ type SlaveRole = [
             host: BlobStringReply;
-            port: NumberReply;
-            replicationOffest: NumberReply;
+            port: number;
+            replicationOffest: number;
         }[];
@@ -43,3 +43,3 @@ master?: undefined;
         };
-        state: BlobStringReply<"connect" | "connected" | "connecting" | "sync">;
+        state: BlobStringReply<"connect" | "connecting" | "sync" | "connected">;
         dataReceived: NumberReply;
@@ -46,0 +46,0 @@ replicationOffest?: undefined;

dist/lib/commands/ROLE.js

@@ -18,4 +18,4 @@ "use strict";
                         host,
-                        port,
-                        replicationOffest,
+                        port: Number(port),
+                        replicationOffest: Number(replicationOffest)
                     })),
@@ -30,3 +30,3 @@ };
                         host: masterHost,
-                        port: masterPort,
+                        port: masterPort
                     },
@@ -41,3 +41,3 @@ state,
                     role,
-                    masterNames,
+                    masterNames
                 };
@@ -44,0 +44,0 @@ }

dist/lib/commands/SCAN.d.ts

@@ -1,2 +0,2 @@
-import { CommandArguments, RedisArgument, BlobStringReply, ArrayReply } from '../RESP/types';
+import { RedisArgument, CommandArguments, BlobStringReply, ArrayReply } from '../RESP/types';
 export interface ScanCommonOptions {
@@ -11,2 +11,3 @@ MATCH?: string;
 declare const _default: {
+    readonly FIRST_KEY_INDEX: undefined;
     readonly IS_READ_ONLY: true;
@@ -13,0 +14,0 @@ readonly transformArguments: (this: void, cursor: number, options?: ScanOptions) => CommandArguments;

dist/lib/commands/SCAN.js

@@ -16,2 +16,3 @@ "use strict";
 exports.default = {
+    FIRST_KEY_INDEX: undefined,
     IS_READ_ONLY: true,
@@ -18,0 +19,0 @@ transformArguments(cursor, options) {

dist/lib/commands/SCRIPT_DEBUG.d.ts

@@ -6,4 +6,4 @@ import { SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void, mode: 'YES' | 'SYNC' | 'NO') => string[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/SCRIPT_FLUSH.d.ts

@@ -6,4 +6,4 @@ import { SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void, mode?: 'ASYNC' | 'SYNC') => string[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/SCRIPT_KILL.d.ts

@@ -6,4 +6,4 @@ import { SimpleStringReply } from '../RESP/types';
     readonly transformArguments: (this: void) => string[];
-    readonly transformReply: () => SimpleStringReply;
+    readonly transformReply: () => SimpleStringReply<'OK'>;
 };
 export default _default;

dist/lib/commands/SHUTDOWN.js

 "use strict";
-// export function transformArguments(mode?: 'NOSAVE' | 'SAVE'): Array<string> {
-//     const args = ['SHUTDOWN'];
-//     if (mode) {
-//         args.push(mode);
-//     }
-//     return args;
-// }
-// export declare function transformReply(): void;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(options) {
+        const args = ['SHUTDOWN'];
+        if (options?.mode) {
+            args.push(options.mode);
+        }
+        if (options?.NOW) {
+            args.push('NOW');
+        }
+        if (options?.FORCE) {
+            args.push('FORCE');
+        }
+        if (options?.ABORT) {
+            args.push('ABORT');
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/SMOVE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     source: RedisCommandArgument,
-//     destination: RedisCommandArgument,
-//     member: RedisCommandArgument
-// ): RedisCommandArguments {
-//     return ['SMOVE', source, destination, member];
-// }
-// export { transformBooleanReply as transformReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(source, destination, member) {
+        return ['SMOVE', source, destination, member];
+    },
+    transformReply: undefined
+};

dist/lib/commands/SORT_RO.js

 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const SORT_1 = require("./SORT");
+const SORT_1 = __importStar(require("./SORT"));
 exports.default = {
@@ -5,0 +28,0 @@ FIRST_KEY_INDEX: SORT_1.default.FIRST_KEY_INDEX,

dist/lib/commands/SORT_STORE.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const SORT_1 = require("./SORT");
+const SORT_1 = __importDefault(require("./SORT"));
 exports.default = {
@@ -5,0 +8,0 @@ FIRST_KEY_INDEX: 1,

dist/lib/commands/SPOP.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     count?: number
-// ): RedisCommandArguments {
-//     const args = ['SPOP', key];
-//     if (typeof count === 'number') {
-//         args.push(count.toString());
-//     }
-//     return args;
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key) {
+        return ['SPOP', key];
+    },
+    transformReply: undefined
+};

dist/lib/commands/SRANDMEMBER_COUNT.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const SRANDMEMBER_1 = require("./SRANDMEMBER");
+const SRANDMEMBER_1 = __importDefault(require("./SRANDMEMBER"));
 exports.default = {
@@ -5,0 +8,0 @@ FIRST_KEY_INDEX: SRANDMEMBER_1.default.FIRST_KEY_INDEX,

dist/lib/commands/SUNION.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { pushVariadicArguments } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export function transformArguments(
-//     keys: RedisCommandArgument | Array<RedisCommandArgument>
-// ): RedisCommandArguments {
-//     return pushVariadicArguments(['SUNION'], keys);
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: true,
+    transformArguments(keys) {
+        return (0, generic_transformers_1.pushVariadicArguments)(['SUNION'], keys);
+    },
+    transformReply: undefined
+};

dist/lib/commands/SUNIONSTORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { pushVariadicArguments } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     destination: RedisCommandArgument,
-//     keys: RedisCommandArgument | Array<RedisCommandArgument>
-// ): RedisCommandArguments {
-//     return pushVariadicArguments(['SUNIONSTORE', destination], keys);
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(destination, keys) {
+        return (0, generic_transformers_1.pushVariadicArguments)(['SUNIONSTORE', destination], keys);
+    },
+    transformReply: undefined
+};

dist/lib/commands/SWAPDB.js

 "use strict";
-// export function transformArguments(index1: number, index2: number): Array<string> {
-//     return ['SWAPDB', index1.toString(), index2.toString()];
-// }
-// export declare function transformReply(): string;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(index1, index2) {
+        return ['SWAPDB', index1.toString(), index2.toString()];
+    },
+    transformReply: undefined
+};

dist/lib/commands/TIME.js

 "use strict";
-// export function transformArguments(): Array<string> {
-//     return ['TIME'];
-// }
-// interface TimeReply extends Date {
-//     microseconds: number;
-// }
-// export function transformReply(reply: [string, string]): TimeReply {
-//     const seconds = Number(reply[0]),
-//         microseconds = Number(reply[1]),
-//         d: Partial<TimeReply> = new Date(seconds * 1000 + microseconds / 1000);
-//     d.microseconds = microseconds;
-//     return d as TimeReply;
-// }
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: true,
+    transformArguments() {
+        return ['TIME'];
+    },
+    transformReply: undefined
+};

dist/lib/commands/XACK.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { pushVariadicArguments } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     group: RedisCommandArgument,
-//     id: RedisCommandArgument | Array<RedisCommandArgument>
-// ): RedisCommandArguments {
-//     return pushVariadicArguments(['XACK', key, group], id);
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, group, id) {
+        return (0, generic_transformers_1.pushVariadicArguments)(['XACK', key, group], id);
+    },
+    transformReply: undefined
+};

dist/lib/commands/XADD.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// interface XAddOptions {
-//     NOMKSTREAM?: true;
-//     TRIM?: {
-//         strategy?: 'MAXLEN' | 'MINID';
-//         strategyModifier?: '=' | '~';
-//         threshold: number;
-//         limit?: number;
-//     };
-// }
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     id: RedisCommandArgument,
-//     message: Record<string, RedisCommandArgument>,
-//     options?: XAddOptions
-// ): RedisCommandArguments {
-//     const args = ['XADD', key];
-//     if (options?.NOMKSTREAM) {
-//         args.push('NOMKSTREAM');
-//     }
-//     if (options?.TRIM) {
-//         if (options.TRIM.strategy) {
-//             args.push(options.TRIM.strategy);
-//         }
-//         if (options.TRIM.strategyModifier) {
-//             args.push(options.TRIM.strategyModifier);
-//         }
-//         args.push(options.TRIM.threshold.toString());
-//         if (options.TRIM.limit) {
-//             args.push('LIMIT', options.TRIM.limit.toString());
-//         }
-//     }
-//     args.push(id);
-//     for (const [key, value] of Object.entries(message)) {
-//         args.push(key, value);
-//     }
-//     return args;
-// }
-// export declare function transformReply(): string;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushXAddArguments = void 0;
+function pushXAddArguments(args, id, message, options) {
+    if (options?.TRIM) {
+        if (options.TRIM.strategy) {
+            args.push(options.TRIM.strategy);
+        }
+        if (options.TRIM.strategyModifier) {
+            args.push(options.TRIM.strategyModifier);
+        }
+        args.push(options.TRIM.threshold.toString());
+        if (options.TRIM.limit) {
+            args.push('LIMIT', options.TRIM.limit.toString());
+        }
+    }
+    args.push(id);
+    for (const [key, value] of Object.entries(message)) {
+        args.push(key, value);
+    }
+    return args;
+}
+exports.pushXAddArguments = pushXAddArguments;
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, id, message, options) {
+        return pushXAddArguments(['XADD', key], id, message, options);
+    },
+    transformReply: undefined
+};

dist/lib/commands/XAUTOCLAIM_JUSTID.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { transformArguments as transformXAutoClaimArguments } from './XAUTOCLAIM';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export { FIRST_KEY_INDEX } from './XAUTOCLAIM';
@@ -5,0 +6,0 @@ // export function transformArguments(...args: Parameters<typeof transformXAutoClaimArguments>): RedisCommandArguments {

dist/lib/commands/XAUTOCLAIM.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { StreamMessagesReply, transformStreamMessagesReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -5,0 +6,0 @@ // export interface XAutoClaimOptions {

dist/lib/commands/XCLAIM_JUSTID.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { transformArguments as transformXClaimArguments } from './XCLAIM';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export { FIRST_KEY_INDEX } from './XCLAIM';
@@ -5,0 +6,0 @@ // export function transformArguments(...args: Parameters<typeof transformXClaimArguments>): RedisCommandArguments {

dist/lib/commands/XCLAIM.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { pushVariadicArguments } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -5,0 +6,0 @@ // export interface XClaimOptions {

dist/lib/commands/XDEL.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { pushVariadicArguments } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     id: RedisCommandArgument | Array<RedisCommandArgument>
-// ): RedisCommandArguments {
-//     return pushVariadicArguments(['XDEL', key], id);
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, id) {
+        return (0, generic_transformers_1.pushVariadicArguments)(['XDEL', key], id);
+    },
+    transformReply: undefined
+};

dist/lib/commands/XGROUP_CREATE.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -4,0 +5,0 @@ // interface XGroupCreateOptions {

dist/lib/commands/XGROUP_CREATECONSUMER.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -4,0 +5,0 @@ // export function transformArguments(

dist/lib/commands/XGROUP_DELCONSUMER.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -4,0 +5,0 @@ // export function transformArguments(

dist/lib/commands/XGROUP_DESTROY.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -4,0 +5,0 @@ // export function transformArguments(

dist/lib/commands/XGROUP_SETID.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -4,0 +5,0 @@ // export function transformArguments(

dist/lib/commands/XINFO_CONSUMERS.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -15,2 +16,3 @@ // export const IS_READ_ONLY = true;
 //     idle: number;
+//     inactive: number;
 // }>;
@@ -21,4 +23,5 @@ // export function transformReply(rawReply: Array<any>): XInfoConsumersReply {
 //         pending: consumer[3],
-//         idle: consumer[5]
+//         idle: consumer[5],
+//         inactive: consumer[7]
 //     }));
 // }

dist/lib/commands/XINFO_GROUPS.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -4,0 +5,0 @@ // export const IS_READ_ONLY = true;

dist/lib/commands/XINFO_STREAM.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
 // import { StreamMessageReply, transformTuplesReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 2;
@@ -5,0 +6,0 @@ // export const IS_READ_ONLY = true;

dist/lib/commands/XPENDING_RANGE.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -4,0 +5,0 @@ // export const IS_READ_ONLY = true;

dist/lib/commands/XPENDING.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -4,0 +5,0 @@ // export const IS_READ_ONLY = true;

dist/lib/commands/XRANGE.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -4,0 +5,0 @@ // export const IS_READ_ONLY = true;

dist/lib/commands/XREAD.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = (streams: Array<XReadStream> | XReadStream): RedisCommandArgument => {
@@ -4,0 +5,0 @@ //     return Array.isArray(streams) ? streams[0].key : streams.key;

dist/lib/commands/XREADGROUP.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export interface XReadGroupStream {
@@ -4,0 +5,0 @@ //     key: RedisCommandArgument;

dist/lib/commands/XREVRANGE.js

 "use strict";
 // import { RedisCommandArgument, RedisCommandArguments } from '.';
+Object.defineProperty(exports, "__esModule", { value: true });
 // export const FIRST_KEY_INDEX = 1;
@@ -4,0 +5,0 @@ // export const IS_READ_ONLY = true;

dist/lib/commands/XSETID.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// interface XSetIdOptions {
-//     ENTRIESADDED?: number;
-//     MAXDELETEDID?: RedisCommandArgument;
-// }
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     lastId: RedisCommandArgument,
-//     options?: XSetIdOptions
-// ): RedisCommandArguments {
-//     const args = ['XSETID', key, lastId];
-//     if (options?.ENTRIESADDED) {
-//         args.push('ENTRIESADDED', options.ENTRIESADDED.toString());
-//     }
-//     if (options?.MAXDELETEDID) {
-//         args.push('MAXDELETEDID', options.MAXDELETEDID);
-//     }
-//     return args;
-// }
-// export declare function transformReply(): 'OK';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, lastId, options) {
+        const args = ['XSETID', key, lastId];
+        if (options?.ENTRIESADDED) {
+            args.push('ENTRIESADDED', options.ENTRIESADDED.toString());
+        }
+        if (options?.MAXDELETEDID) {
+            args.push('MAXDELETEDID', options.MAXDELETEDID);
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/XTRIM.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// interface XTrimOptions {
-//     strategyModifier?: '=' | '~';
-//     LIMIT?: number;
-// }
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     strategy: 'MAXLEN' | 'MINID',
-//     threshold: number,
-//     options?: XTrimOptions
-// ): RedisCommandArguments {
-//     const args = ['XTRIM', key, strategy];
-//     if (options?.strategyModifier) {
-//         args.push(options.strategyModifier);
-//     }
-//     args.push(threshold.toString());
-//     if (options?.LIMIT) {
-//         args.push('LIMIT', options.LIMIT.toString());
-//     }
-//     return args;
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, strategy, threshold, options) {
+        const args = ['XTRIM', key, strategy];
+        if (options?.strategyModifier) {
+            args.push(options.strategyModifier);
+        }
+        args.push(threshold.toString());
+        if (options?.LIMIT) {
+            args.push('LIMIT', options.LIMIT.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZADD.d.ts

@@ -1,3 +0,3 @@
-import { RedisArgument, NumberReply, DoubleReply } from '../RESP/types';
-import { ZMember, transformDoubleReply } from './generic-transformers';
+import { RedisArgument } from '../RESP/types';
+import { SortedSetMember } from './generic-transformers';
 export interface ZAddOptions {
@@ -23,12 +23,12 @@ condition?: 'NX' | 'XX';
     CH?: boolean;
-    INCR?: boolean;
 }
 declare const _default: {
     readonly FIRST_KEY_INDEX: 1;
-    readonly transformArguments: (this: void, key: RedisArgument, members: ZMember | Array<ZMember>, options?: ZAddOptions) => RedisArgument[];
+    readonly transformArguments: (this: void, key: RedisArgument, members: SortedSetMember | Array<SortedSetMember>, options?: ZAddOptions) => RedisArgument[];
     readonly transformReply: {
-        readonly 2: typeof transformDoubleReply;
-        readonly 3: () => NumberReply | DoubleReply;
+        2: (reply: import("../RESP/types").BlobStringReply) => number;
+        3: () => import("../RESP/types").DoubleReply;
     };
 };
 export default _default;
+export declare function pushMembers(args: Array<RedisArgument>, members: SortedSetMember | Array<SortedSetMember>): void;

dist/lib/commands/ZADD.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pushMembers = void 0;
 const generic_transformers_1 = require("./generic-transformers");
@@ -29,22 +30,20 @@ exports.default = {
         }
-        if (options?.INCR) {
-            args.push('INCR');
-        }
-        if (Array.isArray(members)) {
-            for (const member of members) {
-                pushMember(args, member);
-            }
-        }
-        else {
-            pushMember(args, members);
-        }
+        pushMembers(args, members);
         return args;
     },
-    transformReply: {
-        2: generic_transformers_1.transformDoubleReply,
-        3: undefined
+    transformReply: generic_transformers_1.transformDoubleReply
+};
+function pushMembers(args, members) {
+    if (Array.isArray(members)) {
+        for (const member of members) {
+            pushMember(args, member);
+        }
     }
-};
+    else {
+        pushMember(args, members);
+    }
+}
+exports.pushMembers = pushMembers;
 function pushMember(args, member) {
     args.push((0, generic_transformers_1.transformDoubleArgument)(member.score), member.value);
 }

dist/lib/commands/ZDIFF_WITHSCORES.d.ts

@@ -1,16 +0,16 @@
-import { ArrayReply, BlobStringReply, NumberReply } from '../RESP/types';
-import ZDIFF from './ZDIFF';
-import { transformSortedSetWithScoresReply } from './generic-transformers';
 declare const _default: {
     readonly FIRST_KEY_INDEX: 2;
     readonly IS_READ_ONLY: true;
-    readonly transformArguments: (this: void, keys: Parameters<typeof ZDIFF.transformArguments>[0]) => import("../RESP/types").CommandArguments;
+    readonly transformArguments: (this: void, keys: import("./generic-transformers").RedisVariadicArgument) => import("../RESP/types").CommandArguments;
     readonly transformReply: {
-        readonly 2: typeof transformSortedSetWithScoresReply;
-        readonly 3: (reply: ArrayReply<[BlobStringReply, NumberReply]>) => {
-            value: BlobStringReply;
-            score: NumberReply;
+        2: (reply: import("../RESP/types").ArrayReply<import("../RESP/types").BlobStringReply>) => {
+            value: import("../RESP/types").BlobStringReply;
+            score: number;
         }[];
+        3: (reply: import("../RESP/types").ArrayReply<import("../RESP/types").TuplesReply<[import("../RESP/types").BlobStringReply, import("../RESP/types").DoubleReply]>>) => {
+            value: import("../RESP/types").BlobStringReply;
+            score: import("../RESP/types").DoubleReply;
+        }[];
     };
 };
 export default _default;

dist/lib/commands/ZDIFF_WITHSCORES.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ZDIFF_1 = require("./ZDIFF");
+const ZDIFF_1 = __importDefault(require("./ZDIFF"));
 const generic_transformers_1 = require("./generic-transformers");
 exports.default = {
-    FIRST_KEY_INDEX: 2,
-    IS_READ_ONLY: true,
-    transformArguments(keys) {
-        const args = ZDIFF_1.default.transformArguments(keys);
-        args.push('WITHSCORES');
-        return args;
+    FIRST_KEY_INDEX: ZDIFF_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: ZDIFF_1.default.IS_READ_ONLY,
+    transformArguments(...args) {
+        const redisArgs = ZDIFF_1.default.transformArguments(...args);
+        redisArgs.push('WITHSCORES');
+        return redisArgs;
     },
-    transformReply: {
-        2: generic_transformers_1.transformSortedSetWithScoresReply,
-        3: (reply) => {
-            return reply.map(([value, score]) => ({ value, score }));
-        }
-    }
+    transformReply: generic_transformers_1.transformSortedSetReply
 };

dist/lib/commands/ZINCRBY.d.ts

 import { RedisArgument, DoubleReply } from '../RESP/types';
-import { transformDoubleReply } from './generic-transformers';
 declare const _default: {
@@ -7,6 +6,6 @@ readonly FIRST_KEY_INDEX: 1;
     readonly transformReply: {
-        readonly 2: typeof transformDoubleReply;
-        readonly 3: () => DoubleReply;
+        2: (reply: import("../RESP/types").BlobStringReply) => number;
+        3: () => DoubleReply;
     };
 };
 export default _default;

dist/lib/commands/ZINCRBY.js

@@ -14,6 +14,3 @@ "use strict";
     },
-    transformReply: {
-        2: generic_transformers_1.transformDoubleReply,
-        3: undefined
-    }
+    transformReply: generic_transformers_1.transformDoubleReply
 };

dist/lib/commands/ZINTER_WITHSCORES.d.ts

@@ -1,3 +0,1 @@
-import { ArrayReply, BlobStringReply, DoubleReply } from '../RESP/types';
-import { transformSortedSetWithScoresReply } from './generic-transformers';
 declare const _default: {
@@ -8,9 +6,12 @@ readonly FIRST_KEY_INDEX: 2;
     readonly transformReply: {
-        readonly 2: typeof transformSortedSetWithScoresReply;
-        readonly 3: (reply: ArrayReply<[BlobStringReply, DoubleReply]>) => {
-            member: BlobStringReply;
-            score: DoubleReply;
+        2: (reply: import("../RESP/types").ArrayReply<import("../RESP/types").BlobStringReply>) => {
+            value: import("../RESP/types").BlobStringReply;
+            score: number;
         }[];
+        3: (reply: import("../RESP/types").ArrayReply<import("../RESP/types").TuplesReply<[import("../RESP/types").BlobStringReply, import("../RESP/types").DoubleReply]>>) => {
+            value: import("../RESP/types").BlobStringReply;
+            score: import("../RESP/types").DoubleReply;
+        }[];
     };
 };
 export default _default;

dist/lib/commands/ZINTER_WITHSCORES.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// import { transformArguments as transformZInterArguments } from './ZINTER';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ZINTER_1 = require("./ZINTER");
+const ZINTER_1 = __importDefault(require("./ZINTER"));
 const generic_transformers_1 = require("./generic-transformers");
@@ -15,11 +16,3 @@ exports.default = {
     },
-    transformReply: {
-        2: generic_transformers_1.transformSortedSetWithScoresReply,
-        3: (reply) => {
-            return reply.map(([member, score]) => ({
-                member,
-                score
-            }));
-        }
-    }
+    transformReply: generic_transformers_1.transformSortedSetReply
 };

dist/lib/commands/ZINTER.d.ts

 import { RedisArgument, ArrayReply, BlobStringReply } from '../RESP/types';
+import { ZKeys } from './generic-transformers';
 export type ZInterKeyAndWeight = {
@@ -10,3 +11,3 @@ key: RedisArgument;
 }
-export declare function pushZInterArguments(args: Array<RedisArgument>, keys: ZInterKeys<RedisArgument> | ZInterKeys<ZInterKeyAndWeight>, options?: ZInterOptions): RedisArgument[];
+export declare function pushZInterArguments(args: Array<RedisArgument>, keys: ZKeys, options?: ZInterOptions): RedisArgument[];
 declare const _default: {
@@ -13,0 +14,0 @@ readonly FIRST_KEY_INDEX: 2;

dist/lib/commands/ZINTER.js

@@ -6,28 +6,3 @@ "use strict";
 function pushZInterArguments(args, keys, options) {
-    if (Array.isArray(keys)) {
-        args.push(keys.length.toString());
-        if (keys.length) {
-            if (isPlainKeys(keys)) {
-                args = args.concat(keys);
-            }
-            else {
-                const start = args.length;
-                args[start + keys.length] = 'WEIGHTS';
-                for (let i = 0; i < keys.length; i++) {
-                    const index = start + i;
-                    args[index] = keys[i].key;
-                    args[index + 1 + keys.length] = (0, generic_transformers_1.transformDoubleArgument)(keys[i].weight);
-                }
-            }
-        }
-    }
-    else {
-        args.push('1');
-        if (isPlainKey(keys)) {
-            args.push(keys);
-        }
-        else {
-            args.push(keys.key, 'WEIGHTS', (0, generic_transformers_1.transformDoubleArgument)(keys.weight));
-        }
-    }
+    args = (0, generic_transformers_1.pushZKeysArguments)(args, keys);
     if (options?.AGGREGATE) {
@@ -39,8 +14,2 @@ args.push('AGGREGATE', options.AGGREGATE);
 exports.pushZInterArguments = pushZInterArguments;
-function isPlainKey(key) {
-    return typeof key === 'string' || Buffer.isBuffer(key);
-}
-function isPlainKeys(keys) {
-    return isPlainKey(keys[0]);
-}
 exports.default = {
@@ -47,0 +16,0 @@ FIRST_KEY_INDEX: 2,

dist/lib/commands/ZINTERSTORE.d.ts

 import { RedisArgument, NumberReply } from '../RESP/types';
-import { ZInterKeyAndWeight, ZInterKeys, ZInterOptions } from './ZINTER';
+import { ZInterOptions } from './ZINTER';
+import { ZKeys } from './generic-transformers';
 declare const _default: {
     readonly FIRST_KEY_INDEX: 1;
-    readonly transformArguments: (this: void, destination: RedisArgument, keys: ZInterKeys<RedisArgument> | ZInterKeys<ZInterKeyAndWeight>, options?: ZInterOptions) => RedisArgument[];
+    readonly IS_READ_ONLY: false;
+    readonly transformArguments: (this: void, destination: RedisArgument, keys: ZKeys, options?: ZInterOptions) => RedisArgument[];
     readonly transformReply: () => NumberReply;
 };
 export default _default;

dist/lib/commands/ZINTERSTORE.js

@@ -6,2 +6,3 @@ "use strict";
     FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
     transformArguments(destination, keys, options) {
@@ -8,0 +9,0 @@ return (0, ZINTER_1.pushZInterArguments)(['ZINTERSTORE', destination], keys, options);

dist/lib/commands/ZMPOP.js

 "use strict";
-// import { NullReply, TuplesReply, BlobStringReply, DoubleReply, ArrayReply, Resp2Reply, Command, RedisArgument } from '../RESP/types';
-// import { pushVariadicArgument, RedisVariadicArgument, SortedSetSide } from './generic-transformers';
-// export interface ZMPopOptions {
-//   COUNT?: number;
-// }
-// export type ZMPopRawReply = NullReply | TuplesReply<[
-//   key: BlobStringReply,
-//   elements: ArrayReply<TuplesReply<[
-//     member: BlobStringReply,
-//     score: DoubleReply
-//   ]>>
-// ]>;
-// export function pushZMPopArguments(
-//   args: Array<RedisArgument>,
-//   keys: RedisVariadicArgument,
-//   side: SortedSetSide,
-//   options: ZMPopOptions
-// )
-// export default {
-//   FIRST_KEY_INDEX: 2,
-//   IS_READ_ONLY: false,
-//   transformArguments(
-//     keys: RedisVariadicArgument,
-//     side: SortedSetSide,
-//     options?: ZMPopOptions
-//   ) {
-//     const args = pushVariadicArgument(['ZMPOP'], keys);
-//     args.push(side);
-//     if (options?.COUNT) {
-//       args.push('COUNT', options.COUNT.toString());
-//     }
-//     return args;
-//   },
-//   transformReply: {
-//     2: (reply: Resp2Reply<ZMPopRawReply>) => {
-//       return reply === null ? null : {
-//         key: reply[0],
-//         elements: reply[1].map(([member, score]) => ({
-//           member,
-//           score: Number(score)
-//         }))
-//       };
-//     },
-//     3: (reply: ZMPopRawReply) => {
-//       return reply === null ? null : {
-//         key: reply[0],
-//         elements: reply[1].map(([member, score]) => ({
-//           member,
-//           score
-//         }))
-//       };
-//     },
-//   }
-// } as const satisfies Command;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 2,
+    IS_READ_ONLY: false,
+    transformArguments(keys, side, options) {
+        const args = (0, generic_transformers_1.pushVariadicArgument)(['ZMPOP'], keys);
+        args.push(side);
+        if (options?.COUNT) {
+            args.push('COUNT', options.COUNT.toString());
+        }
+        return args;
+    },
+    transformReply: {
+        2: (reply) => {
+            return reply === null ? null : {
+                key: reply[0],
+                members: reply[1].map(([value, score]) => ({
+                    value,
+                    score: Number(score)
+                }))
+            };
+        },
+        3: (reply) => {
+            return reply === null ? null : {
+                key: reply[0],
+                members: generic_transformers_1.transformSortedSetReply[3](reply[1])
+            };
+        },
+    }
+};

dist/lib/commands/ZMSCORE.js

@@ -12,3 +12,3 @@ "use strict";
         2: (reply) => {
-            return reply.map(score => score === null ? null : Number(score));
+            return reply.map(generic_transformers_1.transformNullableDoubleReply[2]);
         },
@@ -15,0 +15,0 @@ 3: undefined

dist/lib/commands/ZPOPMAX_COUNT.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformArguments as transformZPopMaxArguments } from './ZPOPMAX';
-// export { FIRST_KEY_INDEX } from './ZPOPMAX';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     count: number
-// ): RedisCommandArguments {
-//     return [
-//         ...transformZPopMaxArguments(key),
-//         count.toString()
-//     ];
-// }
-// export { transformSortedSetWithScoresReply as transformReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(key, count) {
+        return ['ZPOPMAX', key, count.toString()];
+    },
+    transformReply: generic_transformers_1.transformSortedSetReply
+};

dist/lib/commands/ZPOPMAX.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
-//     return [
-//         'ZPOPMAX',
-//         key
-//     ];
-// }
-// export { transformSortedSetMemberNullReply as transformReply } from './generic-transformers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZPOPMIN_1 = __importDefault(require("./ZPOPMIN"));
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key) {
+        return ['ZPOPMAX', key];
+    },
+    transformReply: ZPOPMIN_1.default.transformReply
+};

dist/lib/commands/ZPOPMIN_COUNT.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformArguments as transformZPopMinArguments } from './ZPOPMIN';
-// export { FIRST_KEY_INDEX } from './ZPOPMIN';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     count: number
-// ): RedisCommandArguments {
-//     return [
-//         ...transformZPopMinArguments(key),
-//         count.toString()
-//     ];
-// }
-// export { transformSortedSetWithScoresReply as transformReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: undefined,
+    IS_READ_ONLY: false,
+    transformArguments(key, count) {
+        return ['ZPOPMIN', key, count.toString()];
+    },
+    transformReply: generic_transformers_1.transformSortedSetReply
+};

dist/lib/commands/ZPOPMIN.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
-//     return [
-//         'ZPOPMIN',
-//         key
-//     ];
-// }
-// export { transformSortedSetMemberNullReply as transformReply } from './generic-transformers';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key) {
+        return ['ZPOPMIN', key];
+    },
+    transformReply: {
+        2: (reply) => {
+            if (reply.length === 0)
+                return null;
+            return {
+                value: reply[0],
+                score: Number(reply[1])
+            };
+        },
+        3: (reply) => {
+            if (reply.length === 0)
+                return null;
+            return {
+                value: reply[0],
+                score: reply[1]
+            };
+        }
+    }
+};

dist/lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.d.ts

@@ -11,3 +11,3 @@ import { RedisArgument } from '../RESP/types';
         }[];
-        3: (reply: import("../RESP/types").ArrayReply<[import("../RESP/types").BlobStringReply, import("../RESP/types").DoubleReply]>) => {
+        3: (reply: import("../RESP/types").ArrayReply<import("../RESP/types").TuplesReply<[import("../RESP/types").BlobStringReply, import("../RESP/types").DoubleReply]>>) => {
             value: import("../RESP/types").BlobStringReply;
@@ -14,0 +14,0 @@ score: import("../RESP/types").DoubleReply;

dist/lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ZRANDMEMBER_COUNT_1 = require("./ZRANDMEMBER_COUNT");
+const ZRANDMEMBER_COUNT_1 = __importDefault(require("./ZRANDMEMBER_COUNT"));
 const generic_transformers_1 = require("./generic-transformers");
@@ -5,0 +8,0 @@ exports.default = {

dist/lib/commands/ZRANDMEMBER_COUNT.js

 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ZRANDMEMBER_1 = require("./ZRANDMEMBER");
+const ZRANDMEMBER_1 = __importDefault(require("./ZRANDMEMBER"));
 exports.default = {
@@ -5,0 +8,0 @@ FIRST_KEY_INDEX: ZRANDMEMBER_1.default.FIRST_KEY_INDEX,

dist/lib/commands/ZRANGE_WITHSCORES.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// import { transformArguments as transformZRangeArguments } from './ZRANGE';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZRANGE';
-// export function transformArguments(...args: Parameters<typeof transformZRangeArguments>): RedisCommandArguments {
-//     return [
-//         ...transformZRangeArguments(...args),
-//         'WITHSCORES'
-//     ];
-// }
-// export { transformSortedSetWithScoresReply as transformReply } from './generic-transformers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZRANGE_1 = __importDefault(require("./ZRANGE"));
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: ZRANGE_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: ZRANGE_1.default.IS_READ_ONLY,
+    transformArguments(...args) {
+        const redisArgs = ZRANGE_1.default.transformArguments(...args);
+        redisArgs.push('WITHSCORES');
+        return redisArgs;
+    },
+    transformReply: generic_transformers_1.transformSortedSetReply
+};

dist/lib/commands/ZRANGEBYLEX.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformStringDoubleArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export interface ZRangeByLexOptions {
-//     LIMIT?: {
-//         offset: number;
-//         count: number;
-//     };
-// }
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     min: RedisCommandArgument,
-//     max: RedisCommandArgument,
-//     options?: ZRangeByLexOptions
-// ): RedisCommandArguments {
-//     const args = [
-//         'ZRANGEBYLEX',
-//         key,
-//         transformStringDoubleArgument(min),
-//         transformStringDoubleArgument(max)
-//     ];
-//     if (options?.LIMIT) {
-//         args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
-//     }
-//     return args;
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: true,
+    transformArguments(key, min, max, options) {
+        const args = [
+            'ZRANGEBYLEX',
+            key,
+            (0, generic_transformers_1.transformStringDoubleArgument)(min),
+            (0, generic_transformers_1.transformStringDoubleArgument)(max)
+        ];
+        if (options?.LIMIT) {
+            args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZRANGEBYSCORE_WITHSCORES.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { ZRangeByScoreOptions, transformArguments as transformZRangeByScoreArguments } from './ZRANGEBYSCORE';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZRANGEBYSCORE';
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     min: string | number,
-//     max: string | number,
-//     options?: ZRangeByScoreOptions
-// ): RedisCommandArguments {
-//     return [
-//         ...transformZRangeByScoreArguments(key, min, max, options),
-//         'WITHSCORES'
-//     ];
-// }
-// export { transformSortedSetWithScoresReply as transformReply } from './generic-transformers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZRANGEBYSCORE_1 = __importDefault(require("./ZRANGEBYSCORE"));
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: ZRANGEBYSCORE_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: ZRANGEBYSCORE_1.default.IS_READ_ONLY,
+    transformArguments(...args) {
+        const redisArgs = ZRANGEBYSCORE_1.default.transformArguments(...args);
+        redisArgs.push('WITHSCORES');
+        return redisArgs;
+    },
+    transformReply: generic_transformers_1.transformSortedSetReply
+};

dist/lib/commands/ZRANGEBYSCORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformStringDoubleArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export const IS_READ_ONLY = true;
-// export interface ZRangeByScoreOptions {
-//     LIMIT?: {
-//         offset: number;
-//         count: number;
-//     };
-// }
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     min: string | number,
-//     max: string | number,
-//     options?: ZRangeByScoreOptions
-// ): RedisCommandArguments {
-//     const args = [
-//         'ZRANGEBYSCORE',
-//         key,
-//         transformStringDoubleArgument(min),
-//         transformStringDoubleArgument(max)
-//     ];
-//     if (options?.LIMIT) {
-//         args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
-//     }
-//     return args;
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: true,
+    transformArguments(key, min, max, options) {
+        const args = [
+            'ZRANGEBYSCORE',
+            key,
+            (0, generic_transformers_1.transformStringDoubleArgument)(min),
+            (0, generic_transformers_1.transformStringDoubleArgument)(max)
+        ];
+        if (options?.LIMIT) {
+            args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZRANGESTORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformStringDoubleArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// interface ZRangeStoreOptions {
-//     BY?: 'SCORE' | 'LEX';
-//     REV?: true;
-//     LIMIT?: {
-//         offset: number;
-//         count: number;
-//     };
-//     WITHSCORES?: true;
-// }
-// export function transformArguments(
-//     dst: RedisCommandArgument,
-//     src: RedisCommandArgument,
-//     min: RedisCommandArgument | number,
-//     max: RedisCommandArgument | number,
-//     options?: ZRangeStoreOptions
-// ): RedisCommandArguments {
-//     const args = [
-//         'ZRANGESTORE',
-//         dst,
-//         src,
-//         transformStringDoubleArgument(min),
-//         transformStringDoubleArgument(max)
-//     ];
-//     switch (options?.BY) {
-//         case 'SCORE':
-//             args.push('BYSCORE');
-//             break;
-//         case 'LEX':
-//             args.push('BYLEX');
-//             break;
-//     }
-//     if (options?.REV) {
-//         args.push('REV');
-//     }
-//     if (options?.LIMIT) {
-//         args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
-//     }
-//     if (options?.WITHSCORES) {
-//         args.push('WITHSCORES');
-//     }
-//     return args;
-// }
-// export function transformReply(reply: number): number {
-//     if (typeof reply !== 'number') {
-//         throw new TypeError(`Upgrade to Redis 6.2.5 and up (https://github.com/redis/redis/pull/9089)`);
-//     }
-//     return reply;
-// }
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(destination, source, min, max, options) {
+        const args = [
+            'ZRANGESTORE',
+            destination,
+            source,
+            (0, generic_transformers_1.transformStringDoubleArgument)(min),
+            (0, generic_transformers_1.transformStringDoubleArgument)(max)
+        ];
+        switch (options?.BY) {
+            case 'SCORE':
+                args.push('BYSCORE');
+                break;
+            case 'LEX':
+                args.push('BYLEX');
+                break;
+        }
+        if (options?.REV) {
+            args.push('REV');
+        }
+        if (options?.LIMIT) {
+            args.push('LIMIT', options.LIMIT.offset.toString(), options.LIMIT.count.toString());
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZREMRANGEBYLEX.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformStringDoubleArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     min: RedisCommandArgument | number,
-//     max: RedisCommandArgument | number
-// ): RedisCommandArguments {
-//     return [
-//         'ZREMRANGEBYLEX',
-//         key,
-//         transformStringDoubleArgument(min),
-//         transformStringDoubleArgument(max)
-//     ];
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, min, max) {
+        return [
+            'ZREMRANGEBYLEX',
+            key,
+            (0, generic_transformers_1.transformStringDoubleArgument)(min),
+            (0, generic_transformers_1.transformStringDoubleArgument)(max)
+        ];
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZREMRANGEBYRANK.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     start: number,
-//     stop: number
-// ): RedisCommandArguments {
-//     return ['ZREMRANGEBYRANK', key, start.toString(), stop.toString()];
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, start, stop) {
+        return ['ZREMRANGEBYRANK', key, start.toString(), stop.toString()];
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZREMRANGEBYSCORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { transformStringDoubleArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// export function transformArguments(
-//     key: RedisCommandArgument,
-//     min: RedisCommandArgument | number,
-//     max: RedisCommandArgument | number,
-// ): RedisCommandArguments {
-//     return [
-//         'ZREMRANGEBYSCORE',
-//         key,
-//         transformStringDoubleArgument(min),
-//         transformStringDoubleArgument(max)
-//     ];
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(key, min, max) {
+        return [
+            'ZREMRANGEBYSCORE',
+            key,
+            (0, generic_transformers_1.transformStringDoubleArgument)(min),
+            (0, generic_transformers_1.transformStringDoubleArgument)(max)
+        ];
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZSCAN.d.ts

@@ -1,2 +0,2 @@
-import { RedisArgument, BlobStringReply } from '../RESP/types';
+import { RedisArgument, ArrayReply, BlobStringReply } from '../RESP/types';
 import { ScanCommonOptions } from './SCAN';
@@ -11,3 +11,3 @@ export interface HScanEntry {
     readonly transformArguments: (this: void, key: RedisArgument, cursor: number, options?: ScanCommonOptions) => import("../RESP/types").CommandArguments;
-    readonly transformReply: (this: void, [cursor, rawMembers]: [BlobStringReply, Array<BlobStringReply>]) => {
+    readonly transformReply: (this: void, [cursor, rawMembers]: [BlobStringReply, ArrayReply<BlobStringReply>]) => {
         cursor: number;
@@ -14,0 +14,0 @@ members: {

dist/lib/commands/ZSCAN.js

@@ -12,15 +12,7 @@ "use strict";
     transformReply([cursor, rawMembers]) {
-        const members = [];
-        let i = 0;
-        while (i < rawMembers.length) {
-            members.push({
-                value: rawMembers[i++],
-                score: (0, generic_transformers_1.transformDoubleReply)(rawMembers[i++])
-            });
-        }
         return {
             cursor: Number(cursor),
-            members
+            members: generic_transformers_1.transformSortedSetReply[2](rawMembers)
         };
     }
 };

dist/lib/commands/ZSCORE.d.ts

@@ -1,3 +0,2 @@
-import { DoubleReply, NullReply, RedisArgument } from '../RESP/types';
-import { transformNullableDoubleReply } from './generic-transformers';
+import { RedisArgument } from '../RESP/types';
 declare const _default: {
@@ -8,6 +7,6 @@ readonly FIRST_KEY_INDEX: 1;
     readonly transformReply: {
-        readonly 2: typeof transformNullableDoubleReply;
-        readonly 3: () => DoubleReply | NullReply;
+        2: (reply: import("../RESP/types").BlobStringReply) => number | null;
+        3: () => import("../RESP/types").DoubleReply;
     };
 };
 export default _default;

dist/lib/commands/ZSCORE.js

@@ -10,6 +10,3 @@ "use strict";
     },
-    transformReply: {
-        2: generic_transformers_1.transformNullableDoubleReply,
-        3: undefined
-    }
+    transformReply: generic_transformers_1.transformNullableDoubleReply
 };

dist/lib/commands/ZUNION_WITHSCORES.js

 "use strict";
-// import { RedisCommandArguments } from '.';
-// import { transformArguments as transformZUnionArguments } from './ZUNION';
-// export { FIRST_KEY_INDEX, IS_READ_ONLY } from './ZUNION';
-// export function transformArguments(...args: Parameters<typeof transformZUnionArguments>): RedisCommandArguments {
-//     return [
-//         ...transformZUnionArguments(...args),
-//         'WITHSCORES'
-//     ];
-// }
-// export { transformSortedSetWithScoresReply as transformReply } from './generic-transformers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ZUNION_1 = __importDefault(require("./ZUNION"));
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: ZUNION_1.default.FIRST_KEY_INDEX,
+    IS_READ_ONLY: ZUNION_1.default.IS_READ_ONLY,
+    transformArguments(...args) {
+        const redisArgs = ZUNION_1.default.transformArguments(...args);
+        redisArgs.push('WITHSCORES');
+        return redisArgs;
+    },
+    transformReply: generic_transformers_1.transformSortedSetReply
+};

dist/lib/commands/ZUNION.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { pushVariadicArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 2;
-// export const IS_READ_ONLY = true;
-// interface ZUnionOptions {
-//     WEIGHTS?: Array<number>;
-//     AGGREGATE?: 'SUM' | 'MIN' | 'MAX';
-// }
-// export function transformArguments(
-//     keys: Array<RedisCommandArgument> | RedisCommandArgument,
-//     options?: ZUnionOptions
-// ): RedisCommandArguments {
-//     const args = pushVariadicArgument(['ZUNION'], keys);
-//     if (options?.WEIGHTS) {
-//         args.push('WEIGHTS', ...options.WEIGHTS.map(weight => weight.toString()));
-//     }
-//     if (options?.AGGREGATE) {
-//         args.push('AGGREGATE', options.AGGREGATE);
-//     }
-//     return args;
-// }
-// export declare function transformReply(): Array<RedisCommandArgument>;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 2,
+    IS_READ_ONLY: true,
+    transformArguments(keys, options) {
+        const args = (0, generic_transformers_1.pushZKeysArguments)(['ZUNION'], keys);
+        if (options?.AGGREGATE) {
+            args.push('AGGREGATE', options.AGGREGATE);
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/commands/ZUNIONSTORE.js

 "use strict";
-// import { RedisCommandArgument, RedisCommandArguments } from '.';
-// import { pushVariadicArgument } from './generic-transformers';
-// export const FIRST_KEY_INDEX = 1;
-// interface ZUnionOptions {
-//     WEIGHTS?: Array<number>;
-//     AGGREGATE?: 'SUM' | 'MIN' | 'MAX';
-// }
-// export function transformArguments(
-//     destination: RedisCommandArgument,
-//     keys: Array<RedisCommandArgument> | RedisCommandArgument,
-//     options?: ZUnionOptions
-// ): RedisCommandArguments {
-//     const args = pushVariadicArgument(['ZUNIONSTORE', destination], keys);
-//     if (options?.WEIGHTS) {
-//         args.push('WEIGHTS', ...options.WEIGHTS.map(weight => weight.toString()));
-//     }
-//     if (options?.AGGREGATE) {
-//         args.push('AGGREGATE', options.AGGREGATE);
-//     }
-//     return args;
-// }
-// export declare function transformReply(): number;
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    FIRST_KEY_INDEX: 1,
+    IS_READ_ONLY: false,
+    transformArguments(destination, keys, options) {
+        const args = (0, generic_transformers_1.pushZKeysArguments)(['ZUNIONSTORE', destination], keys);
+        if (options?.AGGREGATE) {
+            args.push('AGGREGATE', options.AGGREGATE);
+        }
+        return args;
+    },
+    transformReply: undefined
+};

dist/lib/errors.js

@@ -55,14 +55,2 @@ "use strict";
         super(originalError.message);
-        Object.defineProperty(this, "originalError", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "socketError", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.originalError = originalError;
@@ -69,0 +57,0 @@ this.socketError = socketError;

dist/lib/multi-command.d.ts

 import { CommandArguments, RedisScript, TransformReply } from './RESP/types';
+export type MULTI_REPLY = {
+    GENERIC: 'generic';
+    TYPED: 'typed';
+};
+export type MultiReply = MULTI_REPLY[keyof MULTI_REPLY];
+export type MultiReplyType<T extends MultiReply, REPLIES> = T extends MULTI_REPLY['TYPED'] ? REPLIES : Array<unknown>;
 export interface RedisMultiQueuedCommand {
@@ -7,9 +13,7 @@ args: CommandArguments;
 export default class RedisMultiCommand {
-    static generateChainId(): symbol;
     readonly queue: Array<RedisMultiQueuedCommand>;
     readonly scriptsInUse: Set<string>;
-    addCommand(args: CommandArguments, transformReply?: TransformReply): this;
-    addScript(script: RedisScript, args: CommandArguments, transformReply?: TransformReply): this;
-    handleExecReplies(rawReplies: Array<unknown>): Array<unknown>;
+    addCommand(args: CommandArguments, transformReply?: TransformReply): void;
+    addScript(script: RedisScript, args: CommandArguments, transformReply?: TransformReply): void;
     transformReplies(rawReplies: Array<unknown>): Array<unknown>;
 }

dist/lib/multi-command.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("./errors");
 class RedisMultiCommand {
     constructor() {
-        Object.defineProperty(this, "queue", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "scriptsInUse", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Set()
-        });
+        this.queue = [];
+        this.scriptsInUse = new Set();
     }
-    static generateChainId() {
-        return Symbol('RedisMultiCommand Chain Id');
-    }
     addCommand(args, transformReply) {
@@ -27,6 +13,6 @@ this.queue.push({
         });
-        return this;
     }
     addScript(script, args, transformReply) {
         const redisArgs = [];
+        redisArgs.preserve = args.preserve;
         if (this.scriptsInUse.has(script.SHA1)) {
@@ -43,12 +29,4 @@ redisArgs.push('EVALSHA', script.SHA1);
         redisArgs.push(...args);
-        redisArgs.preserve = args.preserve;
-        return this.addCommand(redisArgs, transformReply);
+        this.addCommand(redisArgs, transformReply);
     }
-    handleExecReplies(rawReplies) {
-        const execReply = rawReplies[rawReplies.length - 1];
-        if (execReply === null) {
-            throw new errors_1.WatchError();
-        }
-        return this.transformReplies(execReply);
-    }
     transformReplies(rawReplies) {
@@ -55,0 +33,0 @@ return rawReplies.map((reply, i) => {

dist/lib/RESP/decoder.d.ts

 /// <reference types="node" />
 import { ErrorReply } from '../errors';
-import { Flags } from './types';
+import { TypeMapping } from './types';
 export declare const RESP_TYPES: {
@@ -20,3 +20,3 @@ readonly NULL: 95;
 };
-export declare const PUSH_FLAGS: {
+export declare const PUSH_TYPE_MAPPING: {
     36: BufferConstructor;
@@ -28,6 +28,6 @@ };
     onPush(push: Array<any>): unknown;
-    getFlags(): Flags;
+    getTypeMapping(): TypeMapping;
 }
 export declare class Decoder {
-    private _config;
+    private readonly _config;
     private _cursor;
@@ -34,0 +34,0 @@ private _next;

dist/lib/RESP/decoder.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decoder = exports.PUSH_FLAGS = exports.RESP_TYPES = void 0;
+exports.Decoder = exports.PUSH_TYPE_MAPPING = exports.RESP_TYPES = void 0;
 // @ts-nocheck
@@ -36,3 +36,3 @@ const verbatim_string_1 = require("./verbatim-string");
 };
-exports.PUSH_FLAGS = {
+exports.PUSH_TYPE_MAPPING = {
     [exports.RESP_TYPES.BLOB_STRING]: Buffer
@@ -42,20 +42,3 @@ };
     constructor(config) {
-        Object.defineProperty(this, "_config", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "_cursor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "_next", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+        this._cursor = 0;
         this._config = config;
@@ -104,11 +87,11 @@ }
             case exports.RESP_TYPES.BIG_NUMBER:
-                return this._handleDecodedValue(this._config.onReply, this._decodeBigNumber(this._config.getFlags()[exports.RESP_TYPES.BIG_NUMBER], chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeBigNumber(this._config.getTypeMapping()[exports.RESP_TYPES.BIG_NUMBER], chunk));
             case exports.RESP_TYPES.DOUBLE:
-                return this._handleDecodedValue(this._config.onReply, this._decodeDouble(this._config.getFlags()[exports.RESP_TYPES.DOUBLE], chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeDouble(this._config.getTypeMapping()[exports.RESP_TYPES.DOUBLE], chunk));
             case exports.RESP_TYPES.SIMPLE_STRING:
-                return this._handleDecodedValue(this._config.onReply, this._decodeSimpleString(this._config.getFlags()[exports.RESP_TYPES.SIMPLE_STRING], chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeSimpleString(this._config.getTypeMapping()[exports.RESP_TYPES.SIMPLE_STRING], chunk));
             case exports.RESP_TYPES.BLOB_STRING:
-                return this._handleDecodedValue(this._config.onReply, this._decodeBlobString(this._config.getFlags()[exports.RESP_TYPES.BLOB_STRING], chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeBlobString(this._config.getTypeMapping()[exports.RESP_TYPES.BLOB_STRING], chunk));
             case exports.RESP_TYPES.VERBATIM_STRING:
-                return this._handleDecodedValue(this._config.onReply, this._decodeVerbatimString(this._config.getFlags()[exports.RESP_TYPES.VERBATIM_STRING], chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeVerbatimString(this._config.getTypeMapping()[exports.RESP_TYPES.VERBATIM_STRING], chunk));
             case exports.RESP_TYPES.SIMPLE_ERROR:
@@ -119,9 +102,11 @@ return this._handleDecodedValue(this._config.onErrorReply, this._decodeSimpleError(chunk));
             case exports.RESP_TYPES.ARRAY:
-                return this._handleDecodedValue(this._config.onReply, this._decodeArray(this._config.getFlags(), chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeArray(this._config.getTypeMapping(), chunk));
             case exports.RESP_TYPES.SET:
-                return this._handleDecodedValue(this._config.onReply, this._decodeSet(this._config.getFlags(), chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeSet(this._config.getTypeMapping(), chunk));
             case exports.RESP_TYPES.MAP:
-                return this._handleDecodedValue(this._config.onReply, this._decodeMap(this._config.getFlags(), chunk));
+                return this._handleDecodedValue(this._config.onReply, this._decodeMap(this._config.getTypeMapping(), chunk));
             case exports.RESP_TYPES.PUSH:
-                return this._handleDecodedValue(this._config.onPush, this._decodeArray(exports.PUSH_FLAGS, chunk));
+                return this._handleDecodedValue(this._config.onPush, this._decodeArray(exports.PUSH_TYPE_MAPPING, chunk));
+            default:
+                throw new Error(`Unknown RESP type ${type} "${String.fromCharCode(type)}"`);
         }
@@ -185,4 +170,4 @@ }
     }
-    _decodeBigNumber(flag, chunk) {
-        if (flag === String) {
+    _decodeBigNumber(type, chunk) {
+        if (type === String) {
             return this._decodeSimpleString(String, chunk);
@@ -224,4 +209,4 @@ }
     }
-    _decodeDouble(flag, chunk) {
-        if (flag === String) {
+    _decodeDouble(type, chunk) {
+        if (type === String) {
             return this._decodeSimpleString(String, chunk);
@@ -336,24 +321,24 @@ }
     }
-    _decodeSimpleString(flag, chunk) {
+    _decodeSimpleString(type, chunk) {
         const start = this._cursor, crlfIndex = this._findCRLF(chunk, start);
         if (crlfIndex === -1) {
-            return this._continueDecodeSimpleString.bind(this, [chunk.subarray(start)], flag);
+            return this._continueDecodeSimpleString.bind(this, [chunk.subarray(start)], type);
         }
         const slice = chunk.subarray(start, crlfIndex);
-        return flag === Buffer ?
+        return type === Buffer ?
             slice :
             slice.toString();
     }
-    _continueDecodeSimpleString(chunks, flag, chunk) {
+    _continueDecodeSimpleString(chunks, type, chunk) {
         const start = this._cursor, crlfIndex = this._findCRLF(chunk, start);
         if (crlfIndex === -1) {
             chunks.push(chunk.subarray(start));
-            return this._continueDecodeSimpleString.bind(this, chunks, flag);
+            return this._continueDecodeSimpleString.bind(this, chunks, type);
         }
         chunks.push(chunk.subarray(start, crlfIndex));
-        return flag === Buffer ?
+        return type === Buffer ?
             Buffer.concat(chunks) :
             chunks.join('');
     }
-    _decodeBlobString(flag, chunk) {
+    _decodeBlobString(type, chunk) {
         // RESP 2 bulk string null
@@ -367,20 +352,20 @@ // https://github.com/redis/redis-specifications/blob/master/protocol/RESP2.md#resp-bulk-strings
         if (typeof length === 'function') {
-            return this._continueDecodeBlobStringLength.bind(this, length, flag);
+            return this._continueDecodeBlobStringLength.bind(this, length, type);
         }
         else if (this._cursor >= chunk.length) {
-            return this._decodeBlobStringWithLength.bind(this, length, flag);
+            return this._decodeBlobStringWithLength.bind(this, length, type);
         }
-        return this._decodeBlobStringWithLength(length, flag, chunk);
+        return this._decodeBlobStringWithLength(length, type, chunk);
     }
-    _continueDecodeBlobStringLength(lengthCb, flag, chunk) {
+    _continueDecodeBlobStringLength(lengthCb, type, chunk) {
         const length = lengthCb(chunk);
         if (typeof length === 'function') {
-            return this._continueDecodeBlobStringLength.bind(this, length, flag);
+            return this._continueDecodeBlobStringLength.bind(this, length, type);
         }
         else if (this._cursor >= chunk.length) {
-            return this._decodeBlobStringWithLength.bind(this, length, flag);
+            return this._decodeBlobStringWithLength.bind(this, length, type);
         }
-        return this._decodeBlobStringWithLength(length, flag, chunk);
+        return this._decodeBlobStringWithLength(length, type, chunk);
     }
-    _decodeStringWithLength(length, skip, flag, chunk) {
+    _decodeStringWithLength(length, skip, type, chunk) {
         const end = this._cursor + length;
@@ -390,11 +375,11 @@ if (end >= chunk.length) {
             this._cursor = chunk.length;
-            return this._continueDecodeStringWithLength.bind(this, length - slice.length, [slice], skip, flag);
+            return this._continueDecodeStringWithLength.bind(this, length - slice.length, [slice], skip, type);
         }
         const slice = chunk.subarray(this._cursor, end);
         this._cursor = end + skip;
-        return flag === Buffer ?
+        return type === Buffer ?
             slice :
             slice.toString();
     }
-    _continueDecodeStringWithLength(length, chunks, skip, flag, chunk) {
+    _continueDecodeStringWithLength(length, chunks, skip, type, chunk) {
         const end = this._cursor + length;
@@ -405,25 +390,25 @@ if (end >= chunk.length) {
             this._cursor = chunk.length;
-            return this._continueDecodeStringWithLength.bind(this, length - slice.length, chunks, flag);
+            return this._continueDecodeStringWithLength.bind(this, length - slice.length, chunks, skip, type);
         }
         chunks.push(chunk.subarray(this._cursor, end));
         this._cursor = end + skip;
-        return flag === Buffer ?
+        return type === Buffer ?
             Buffer.concat(chunks) :
             chunks.join('');
     }
-    _decodeBlobStringWithLength(length, flag, chunk) {
-        return this._decodeStringWithLength(length, 2, flag, chunk);
+    _decodeBlobStringWithLength(length, type, chunk) {
+        return this._decodeStringWithLength(length, 2, type, chunk);
     }
-    _decodeVerbatimString(flag, chunk) {
-        return this._continueDecodeVerbatimStringLength(this._decodeUnsingedNumber.bind(this, 0), flag, chunk);
+    _decodeVerbatimString(type, chunk) {
+        return this._continueDecodeVerbatimStringLength(this._decodeUnsingedNumber.bind(this, 0), type, chunk);
     }
-    _continueDecodeVerbatimStringLength(lengthCb, flag, chunk) {
+    _continueDecodeVerbatimStringLength(lengthCb, type, chunk) {
         const length = lengthCb(chunk);
         return typeof length === 'function' ?
-            this._continueDecodeVerbatimStringLength.bind(this, length, flag) :
-            this._decodeVerbatimStringWithLength(length, flag, chunk);
+            this._continueDecodeVerbatimStringLength.bind(this, length, type) :
+            this._decodeVerbatimStringWithLength(length, type, chunk);
     }
-    _decodeVerbatimStringWithLength(length, flag, chunk) {
+    _decodeVerbatimStringWithLength(length, type, chunk) {
         const stringLength = length - 4; // skip <format>:
-        if (flag === verbatim_string_1.VerbatimString) {
+        if (type === verbatim_string_1.VerbatimString) {
             return this._decodeVerbatimStringFormat(stringLength, chunk);
@@ -433,4 +418,4 @@ }
         return this._cursor >= chunk.length ?
-            this._decodeBlobStringWithLength.bind(this, stringLength, flag) :
-            this._decodeBlobStringWithLength(stringLength, flag, chunk);
+            this._decodeBlobStringWithLength.bind(this, stringLength, type) :
+            this._decodeBlobStringWithLength(stringLength, type, chunk);
     }
@@ -479,9 +464,9 @@ _decodeVerbatimStringFormat(stringLength, chunk) {
     }
-    _decodeNestedType(flags, chunk) {
+    _decodeNestedType(typeMapping, chunk) {
         const type = chunk[this._cursor];
         return ++this._cursor === chunk.length ?
-            this._decodeNestedTypeValue.bind(this, type, flags) :
-            this._decodeNestedTypeValue(type, flags, chunk);
+            this._decodeNestedTypeValue.bind(this, type, typeMapping) :
+            this._decodeNestedTypeValue(type, typeMapping, chunk);
     }
-    _decodeNestedTypeValue(type, flags, chunk) {
+    _decodeNestedTypeValue(type, typeMapping, chunk) {
         switch (type) {
@@ -495,11 +480,11 @@ case exports.RESP_TYPES.NULL:
             case exports.RESP_TYPES.BIG_NUMBER:
-                return this._decodeBigNumber(flags[exports.RESP_TYPES.BIG_NUMBER], chunk);
+                return this._decodeBigNumber(typeMapping[exports.RESP_TYPES.BIG_NUMBER], chunk);
             case exports.RESP_TYPES.DOUBLE:
-                return this._decodeDouble(flags[exports.RESP_TYPES.DOUBLE], chunk);
+                return this._decodeDouble(typeMapping[exports.RESP_TYPES.DOUBLE], chunk);
             case exports.RESP_TYPES.SIMPLE_STRING:
-                return this._decodeSimpleString(flags[exports.RESP_TYPES.SIMPLE_STRING], chunk);
+                return this._decodeSimpleString(typeMapping[exports.RESP_TYPES.SIMPLE_STRING], chunk);
             case exports.RESP_TYPES.BLOB_STRING:
-                return this._decodeBlobString(flags[exports.RESP_TYPES.BLOB_STRING], chunk);
+                return this._decodeBlobString(typeMapping[exports.RESP_TYPES.BLOB_STRING], chunk);
             case exports.RESP_TYPES.VERBATIM_STRING:
-                return this._decodeVerbatimString(flags[exports.RESP_TYPES.VERBATIM_STRING], chunk);
+                return this._decodeVerbatimString(typeMapping[exports.RESP_TYPES.VERBATIM_STRING], chunk);
             case exports.RESP_TYPES.SIMPLE_ERROR:
@@ -510,10 +495,12 @@ return this._decodeSimpleError(chunk);
             case exports.RESP_TYPES.ARRAY:
-                return this._decodeArray(flags, chunk);
+                return this._decodeArray(typeMapping, chunk);
             case exports.RESP_TYPES.SET:
-                return this._decodeSet(flags, chunk);
+                return this._decodeSet(typeMapping, chunk);
             case exports.RESP_TYPES.MAP:
-                return this._decodeMap(flags, chunk);
+                return this._decodeMap(typeMapping, chunk);
+            default:
+                throw new Error(`Unknown RESP type ${type} "${String.fromCharCode(type)}"`);
         }
     }
-    _decodeArray(flags, chunk) {
+    _decodeArray(typeMapping, chunk) {
         // RESP 2 null
@@ -525,20 +512,20 @@ // https://github.com/redis/redis-specifications/blob/master/protocol/RESP2.md#resp-arrays
         }
-        return this._decodeArrayWithLength(this._decodeUnsingedNumber(0, chunk), flags, chunk);
+        return this._decodeArrayWithLength(this._decodeUnsingedNumber(0, chunk), typeMapping, chunk);
     }
-    _decodeArrayWithLength(length, flags, chunk) {
+    _decodeArrayWithLength(length, typeMapping, chunk) {
         return typeof length === 'function' ?
-            this._continueDecodeArrayLength.bind(this, length, flags) :
-            this._decodeArrayItems(new Array(length), 0, flags, chunk);
+            this._continueDecodeArrayLength.bind(this, length, typeMapping) :
+            this._decodeArrayItems(new Array(length), 0, typeMapping, chunk);
     }
-    _continueDecodeArrayLength(lengthCb, flags, chunk) {
-        return this._decodeArrayWithLength(lengthCb(chunk), flags, chunk);
+    _continueDecodeArrayLength(lengthCb, typeMapping, chunk) {
+        return this._decodeArrayWithLength(lengthCb(chunk), typeMapping, chunk);
     }
-    _decodeArrayItems(array, filled, flags, chunk) {
+    _decodeArrayItems(array, filled, typeMapping, chunk) {
         for (let i = filled; i < array.length; i++) {
             if (this._cursor >= chunk.length) {
-                return this._decodeArrayItems.bind(this, array, i, flags);
+                return this._decodeArrayItems.bind(this, array, i, typeMapping);
             }
-            const item = this._decodeNestedType(flags, chunk);
+            const item = this._decodeNestedType(typeMapping, chunk);
             if (typeof item === 'function') {
-                return this._continueDecodeArrayItems.bind(this, array, i, item, flags);
+                return this._continueDecodeArrayItems.bind(this, array, i, item, typeMapping);
             }
@@ -549,37 +536,37 @@ array[i] = item;
     }
-    _continueDecodeArrayItems(array, filled, itemCb, flags, chunk) {
+    _continueDecodeArrayItems(array, filled, itemCb, typeMapping, chunk) {
         const item = itemCb(chunk);
         if (typeof item === 'function') {
-            return this._continueDecodeArrayItems.bind(this, array, filled, item, flags);
+            return this._continueDecodeArrayItems.bind(this, array, filled, item, typeMapping);
         }
         array[filled++] = item;
-        return this._decodeArrayItems(array, filled, flags, chunk);
+        return this._decodeArrayItems(array, filled, typeMapping, chunk);
     }
-    _decodeSet(flags, chunk) {
+    _decodeSet(typeMapping, chunk) {
         const length = this._decodeUnsingedNumber(0, chunk);
         if (typeof length === 'function') {
-            return this._continueDecodeSetLength.bind(this, length, flags);
+            return this._continueDecodeSetLength.bind(this, length, typeMapping);
         }
-        return this._decodeSetItems(length, flags, chunk);
+        return this._decodeSetItems(length, typeMapping, chunk);
     }
-    _continueDecodeSetLength(lengthCb, flags, chunk) {
+    _continueDecodeSetLength(lengthCb, typeMapping, chunk) {
         const length = lengthCb(chunk);
         return typeof length === 'function' ?
-            this._continueDecodeSetLength.bind(this, length, flags) :
-            this._decodeSetItems(length, flags, chunk);
+            this._continueDecodeSetLength.bind(this, length, typeMapping) :
+            this._decodeSetItems(length, typeMapping, chunk);
     }
-    _decodeSetItems(length, flags, chunk) {
-        return flags[exports.RESP_TYPES.SET] === Set ?
-            this._decodeSetAsSet(new Set(), length, flags, chunk) :
-            this._decodeArrayItems(new Array(length), 0, flags, chunk);
+    _decodeSetItems(length, typeMapping, chunk) {
+        return typeMapping[exports.RESP_TYPES.SET] === Set ?
+            this._decodeSetAsSet(new Set(), length, typeMapping, chunk) :
+            this._decodeArrayItems(new Array(length), 0, typeMapping, chunk);
     }
-    _decodeSetAsSet(set, remaining, flags, chunk) {
+    _decodeSetAsSet(set, remaining, typeMapping, chunk) {
         // using `remaining` instead of `length` & `set.size` to make it work even if the set contains duplicates
         while (remaining > 0) {
             if (this._cursor >= chunk.length) {
-                return this._decodeSetAsSet.bind(this, set, remaining, flags);
+                return this._decodeSetAsSet.bind(this, set, remaining, typeMapping);
             }
-            const item = this._decodeNestedType(flags, chunk);
+            const item = this._decodeNestedType(typeMapping, chunk);
             if (typeof item === 'function') {
-                return this._continueDecodeSetAsSet.bind(this, set, remaining, item, flags);
+                return this._continueDecodeSetAsSet.bind(this, set, remaining, item, typeMapping);
             }
@@ -591,49 +578,49 @@ set.add(item);
     }
-    _continueDecodeSetAsSet(set, remaining, itemCb, flags, chunk) {
+    _continueDecodeSetAsSet(set, remaining, itemCb, typeMapping, chunk) {
         const item = itemCb(chunk);
         if (typeof item === 'function') {
-            return this._continueDecodeSetAsSet.bind(this, set, remaining, item, flags);
+            return this._continueDecodeSetAsSet.bind(this, set, remaining, item, typeMapping);
         }
         set.add(item);
-        return this._decodeSetAsSet(set, remaining - 1, flags, chunk);
+        return this._decodeSetAsSet(set, remaining - 1, typeMapping, chunk);
     }
-    _decodeMap(flags, chunk) {
+    _decodeMap(typeMapping, chunk) {
         const length = this._decodeUnsingedNumber(0, chunk);
         if (typeof length === 'function') {
-            return this._continueDecodeMapLength.bind(this, length, flags);
+            return this._continueDecodeMapLength.bind(this, length, typeMapping);
         }
-        return this._decodeMapItems(length, flags, chunk);
+        return this._decodeMapItems(length, typeMapping, chunk);
     }
-    _continueDecodeMapLength(lengthCb, flags, chunk) {
+    _continueDecodeMapLength(lengthCb, typeMapping, chunk) {
         const length = lengthCb(chunk);
         return typeof length === 'function' ?
-            this._continueDecodeMapLength.bind(this, length, flags) :
-            this._decodeMapItems(length, flags, chunk);
+            this._continueDecodeMapLength.bind(this, length, typeMapping) :
+            this._decodeMapItems(length, typeMapping, chunk);
     }
-    _decodeMapItems(length, flags, chunk) {
-        switch (flags[exports.RESP_TYPES.MAP]) {
+    _decodeMapItems(length, typeMapping, chunk) {
+        switch (typeMapping[exports.RESP_TYPES.MAP]) {
             case Map:
-                return this._decodeMapAsMap(new Map(), length, flags, chunk);
+                return this._decodeMapAsMap(new Map(), length, typeMapping, chunk);
             case Array:
-                return this._decodeArrayItems(new Array(length * 2), 0, flags, chunk);
+                return this._decodeArrayItems(new Array(length * 2), 0, typeMapping, chunk);
             default:
-                return this._decodeMapAsObject(Object.create(null), length, flags, chunk);
+                return this._decodeMapAsObject(Object.create(null), length, typeMapping, chunk);
         }
     }
-    _decodeMapAsMap(map, remaining, flags, chunk) {
+    _decodeMapAsMap(map, remaining, typeMapping, chunk) {
         // using `remaining` instead of `length` & `map.size` to make it work even if the map contains duplicate keys
         while (remaining > 0) {
             if (this._cursor >= chunk.length) {
-                return this._decodeMapAsMap.bind(this, map, remaining, flags);
+                return this._decodeMapAsMap.bind(this, map, remaining, typeMapping);
             }
-            const key = this._decodeMapKey(flags, chunk);
+            const key = this._decodeMapKey(typeMapping, chunk);
             if (typeof key === 'function') {
-                return this._continueDecodeMapKey.bind(this, map, remaining, key, flags);
+                return this._continueDecodeMapKey.bind(this, map, remaining, key, typeMapping);
             }
             if (this._cursor >= chunk.length) {
-                return this._continueDecodeMapValue.bind(this, map, remaining, key, this._decodeNestedType.bind(this, flags), flags);
+                return this._continueDecodeMapValue.bind(this, map, remaining, key, this._decodeNestedType.bind(this, typeMapping), typeMapping);
             }
-            const value = this._decodeNestedType(flags, chunk);
+            const value = this._decodeNestedType(typeMapping, chunk);
             if (typeof value === 'function') {
-                return this._continueDecodeMapValue.bind(this, map, remaining, key, value, flags);
+                return this._continueDecodeMapValue.bind(this, map, remaining, key, value, typeMapping);
             }
@@ -645,9 +632,9 @@ map.set(key, value);
     }
-    _decodeMapKey(flags, chunk) {
+    _decodeMapKey(typeMapping, chunk) {
         const type = chunk[this._cursor];
         return ++this._cursor === chunk.length ?
-            this._decodeMapKeyValue.bind(this, type, flags) :
-            this._decodeMapKeyValue(type, flags, chunk);
+            this._decodeMapKeyValue.bind(this, type, typeMapping) :
+            this._decodeMapKeyValue(type, typeMapping, chunk);
     }
-    _decodeMapKeyValue(type, flags, chunk) {
+    _decodeMapKeyValue(type, typeMapping, chunk) {
         switch (type) {
@@ -661,43 +648,43 @@ // decode simple string map key as string (and not as buffer)
             default:
-                return this._decodeNestedTypeValue(type, flags, chunk);
+                return this._decodeNestedTypeValue(type, typeMapping, chunk);
         }
     }
-    _continueDecodeMapKey(map, remaining, keyCb, flags, chunk) {
+    _continueDecodeMapKey(map, remaining, keyCb, typeMapping, chunk) {
         const key = keyCb(chunk);
         if (typeof key === 'function') {
-            return this._continueDecodeMapKey.bind(this, map, remaining, key, flags);
+            return this._continueDecodeMapKey.bind(this, map, remaining, key, typeMapping);
         }
         if (this._cursor >= chunk.length) {
-            return this._continueDecodeMapValue.bind(this, map, remaining, key, this._decodeNestedType.bind(this, flags), flags);
+            return this._continueDecodeMapValue.bind(this, map, remaining, key, this._decodeNestedType.bind(this, typeMapping), typeMapping);
         }
-        const value = this._decodeNestedType(flags, chunk);
+        const value = this._decodeNestedType(typeMapping, chunk);
         if (typeof value === 'function') {
-            return this._continueDecodeMapValue.bind(this, map, remaining, key, value, flags);
+            return this._continueDecodeMapValue.bind(this, map, remaining, key, value, typeMapping);
         }
         map.set(key, value);
-        return this._decodeMapAsMap(map, remaining - 1, flags, chunk);
+        return this._decodeMapAsMap(map, remaining - 1, typeMapping, chunk);
     }
-    _continueDecodeMapValue(map, remaining, key, valueCb, flags, chunk) {
+    _continueDecodeMapValue(map, remaining, key, valueCb, typeMapping, chunk) {
         const value = valueCb(chunk);
         if (typeof value === 'function') {
-            return this._continueDecodeMapValue.bind(this, map, remaining, key, value, flags);
+            return this._continueDecodeMapValue.bind(this, map, remaining, key, value, typeMapping);
         }
         map.set(key, value);
-        return this._decodeMapAsMap(map, remaining - 1, flags, chunk);
+        return this._decodeMapAsMap(map, remaining - 1, typeMapping, chunk);
     }
-    _decodeMapAsObject(object, remaining, flags, chunk) {
+    _decodeMapAsObject(object, remaining, typeMapping, chunk) {
         while (remaining > 0) {
             if (this._cursor >= chunk.length) {
-                return this._decodeMapAsObject.bind(this, object, remaining, flags);
+                return this._decodeMapAsObject.bind(this, object, remaining, typeMapping);
             }
-            const key = this._decodeMapKey(flags, chunk);
+            const key = this._decodeMapKey(typeMapping, chunk);
             if (typeof key === 'function') {
-                return this._continueDecodeMapAsObjectKey.bind(this, object, remaining, key, flags);
+                return this._continueDecodeMapAsObjectKey.bind(this, object, remaining, key, typeMapping);
             }
             if (this._cursor >= chunk.length) {
-                return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, this._decodeNestedType.bind(this, flags), flags);
+                return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, this._decodeNestedType.bind(this, typeMapping), typeMapping);
             }
-            const value = this._decodeNestedType(flags, chunk);
+            const value = this._decodeNestedType(typeMapping, chunk);
             if (typeof value === 'function') {
-                return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, value, flags);
+                return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, value, typeMapping);
             }
@@ -709,39 +696,34 @@ object[key] = value;
     }
-    _continueDecodeMapAsObjectKey(object, remaining, keyCb, flags, chunk) {
+    _continueDecodeMapAsObjectKey(object, remaining, keyCb, typeMapping, chunk) {
         const key = keyCb(chunk);
         if (typeof key === 'function') {
-            return this._continueDecodeMapAsObjectKey.bind(this, object, remaining, key, flags);
+            return this._continueDecodeMapAsObjectKey.bind(this, object, remaining, key, typeMapping);
         }
         if (this._cursor >= chunk.length) {
-            return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, this._decodeNestedType.bind(this, flags), flags);
+            return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, this._decodeNestedType.bind(this, typeMapping), typeMapping);
         }
-        const value = this._decodeNestedType(flags, chunk);
+        const value = this._decodeNestedType(typeMapping, chunk);
         if (typeof value === 'function') {
-            return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, value, flags);
+            return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, value, typeMapping);
         }
         object[key] = value;
-        return this._decodeMapAsObject(object, remaining - 1, flags, chunk);
+        return this._decodeMapAsObject(object, remaining - 1, typeMapping, chunk);
     }
-    _continueDecodeMapAsObjectValue(object, remaining, key, valueCb, flags, chunk) {
+    _continueDecodeMapAsObjectValue(object, remaining, key, valueCb, typeMapping, chunk) {
         const value = valueCb(chunk);
         if (typeof value === 'function') {
-            return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, value, flags);
+            return this._continueDecodeMapAsObjectValue.bind(this, object, remaining, key, value, typeMapping);
         }
         object[key] = value;
-        return this._decodeMapAsObject(object, remaining - 1, flags, chunk);
+        return this._decodeMapAsObject(object, remaining - 1, typeMapping, chunk);
     }
 }
+exports.Decoder = Decoder;
 // Precalculated multipliers for decimal points to improve performance
-// "A Number only keeps about 17 decimal places of precision"
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number
-Object.defineProperty(Decoder, "_DOUBLE_DECIMAL_MULTIPLIERS", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: [
-        0.1, 0.01, 0.001, 0.0001, 0.00001, 0.000001,
-        1e-7, 1e-8, 1e-9, 1e-10, 1e-11, 1e-12,
-        1e-13, 1e-14, 1e-15, 1e-16, 1e-17
-    ]
-});
-exports.Decoder = Decoder;
+// "... about 15 to 17 decimal places ..."
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#:~:text=about%2015%20to%2017%20decimal%20places
+Decoder._DOUBLE_DECIMAL_MULTIPLIERS = [
+    1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6,
+    1e-7, 1e-8, 1e-9, 1e-10, 1e-11, 1e-12,
+    1e-13, 1e-14, 1e-15, 1e-16, 1e-17
+];

dist/lib/RESP/encoder.d.ts

@@ -1,2 +0,2 @@
-import { RedisArgument } from "./types";
+import { RedisArgument } from './types';
 export default function encodeCommand(args: Array<RedisArgument>): Array<RedisArgument>;

dist/lib/RESP/types.d.ts

@@ -41,14 +41,14 @@ /// <reference types="node" />
 }, Map<ReplyUnion, ReplyUnion> | Array<ReplyUnion | ReplyUnion>>;
-export type Reply = ReplyWithFlags<ReplyUnion, {}>;
+export type Reply = ReplyWithTypeMapping<ReplyUnion, {}>;
 export type Flag<T> = ((...args: any) => T) | (new (...args: any) => T);
 type RespTypeUnion<T> = T extends RespType<RespTypes, unknown, unknown, infer FLAG_TYPES> ? FLAG_TYPES : never;
-export type Flags = {
+export type TypeMapping = {
     [P in RespTypes]?: Flag<RespTypeUnion<Extract<ReplyUnion, RespType<P, any, any, any>>>>;
 };
-type MapKey<T, FLAGS extends Flags> = ReplyWithFlags<T, FLAGS & {
+type MapKey<T, TYPE_MAPPING extends TypeMapping> = ReplyWithTypeMapping<T, TYPE_MAPPING & {
     [RESP_TYPES.SIMPLE_STRING]: StringConstructor;
     [RESP_TYPES.BLOB_STRING]: StringConstructor;
 }>;
-export type ReplyWithFlags<REPLY, FLAGS extends Flags> = (REPLY extends RespType<infer RESP_TYPE, infer DEFAULT, infer TYPES, unknown> ? FLAGS[RESP_TYPE] extends Flag<infer T> ? ReplyWithFlags<Extract<DEFAULT | TYPES, T>, FLAGS> : ReplyWithFlags<DEFAULT, FLAGS> : (REPLY extends Array<infer T> ? Array<ReplyWithFlags<T, FLAGS>> : REPLY extends Set<infer T> ? Set<ReplyWithFlags<T, FLAGS>> : REPLY extends Map<infer K, infer V> ? Map<MapKey<K, FLAGS>, ReplyWithFlags<V, FLAGS>> : REPLY extends Date ? REPLY : REPLY extends Buffer ? REPLY : REPLY extends Record<PropertyKey, any> ? {
-    [P in keyof REPLY]: ReplyWithFlags<REPLY[P], FLAGS>;
+export type ReplyWithTypeMapping<REPLY, TYPE_MAPPING extends TypeMapping> = (REPLY extends RespType<infer RESP_TYPE, infer DEFAULT, infer TYPES, unknown> ? TYPE_MAPPING[RESP_TYPE] extends Flag<infer T> ? ReplyWithTypeMapping<Extract<DEFAULT | TYPES, T>, TYPE_MAPPING> : ReplyWithTypeMapping<DEFAULT, TYPE_MAPPING> : (REPLY extends Array<infer T> ? Array<ReplyWithTypeMapping<T, TYPE_MAPPING>> : REPLY extends Set<infer T> ? Set<ReplyWithTypeMapping<T, TYPE_MAPPING>> : REPLY extends Map<infer K, infer V> ? Map<MapKey<K, TYPE_MAPPING>, ReplyWithTypeMapping<V, TYPE_MAPPING>> : REPLY extends Date ? REPLY : REPLY extends Buffer ? REPLY : REPLY extends Record<PropertyKey, any> ? {
+    [P in keyof REPLY]: ReplyWithTypeMapping<REPLY[P], TYPE_MAPPING>;
 } : REPLY));
@@ -129,9 +129,9 @@ export type TransformReply = (this: void, reply: any, preserve?: any) => any;
 ] : T extends Array<infer ITEM> ? Array<Resp2Reply<ITEM>> : never);
-export type Resp2Reply<RESP3REPLY> = (RESP3REPLY extends RespType<infer RESP_TYPE, infer DEFAULT, infer TYPES, unknown> ? RESP_TYPE extends RESP_TYPES['DOUBLE'] ? BlobStringReply : RESP_TYPE extends RESP_TYPES['ARRAY'] | RESP_TYPES['SET'] ? RespType<RESP_TYPE, Resp2Array<DEFAULT>> : RESP_TYPE extends RESP_TYPES['MAP'] ? RespType<RESP_TYPES['ARRAY'], Resp2Array<Extract<TYPES, Array<any>>>> : RespType<RESP_TYPE, DEFAULT, TYPES> : RESP3REPLY);
+export type Resp2Reply<RESP3REPLY> = (RESP3REPLY extends RespType<infer RESP_TYPE, infer DEFAULT, infer TYPES, unknown> ? RESP_TYPE extends RESP_TYPES['DOUBLE'] ? BlobStringReply : RESP_TYPE extends RESP_TYPES['ARRAY'] | RESP_TYPES['SET'] ? RespType<RESP_TYPE, Resp2Array<DEFAULT>> : RESP_TYPE extends RESP_TYPES['MAP'] ? RespType<RESP_TYPES['ARRAY'], Resp2Array<Extract<TYPES, Array<any>>>> : RESP3REPLY : RESP3REPLY);
 export type RespVersions = 2 | 3;
 export type CommandReply<COMMAND extends Command, RESP extends RespVersions> = (COMMAND['transformReply'] extends (...args: any) => infer T ? T : COMMAND['transformReply'] extends Record<RESP, (...args: any) => infer T> ? T : Reply);
-export type CommandSignature<COMMAND extends Command, RESP extends RespVersions, FLAGS extends Flags> = (...args: Parameters<COMMAND['transformArguments']>) => Promise<ReplyWithFlags<CommandReply<COMMAND, RESP>, FLAGS>>;
-export type CommandWithPoliciesSignature<COMMAND extends Command, RESP extends RespVersions, FLAGS extends Flags, POLICIES extends CommandPolicies> = (...args: Parameters<COMMAND['transformArguments']>) => Promise<ReplyWithPolicy<ReplyWithFlags<CommandReply<COMMAND, RESP>, FLAGS>, MergePolicies<COMMAND, POLICIES>>>;
+export type CommandSignature<COMMAND extends Command, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping> = (...args: Parameters<COMMAND['transformArguments']>) => Promise<ReplyWithTypeMapping<CommandReply<COMMAND, RESP>, TYPE_MAPPING>>;
+export type CommandWithPoliciesSignature<COMMAND extends Command, RESP extends RespVersions, TYPE_MAPPING extends TypeMapping, POLICIES extends CommandPolicies> = (...args: Parameters<COMMAND['transformArguments']>) => Promise<ReplyWithPolicy<ReplyWithTypeMapping<CommandReply<COMMAND, RESP>, TYPE_MAPPING>, MergePolicies<COMMAND, POLICIES>>>;
 export type MergePolicies<COMMAND extends Command, POLICIES extends CommandPolicies> = Omit<COMMAND['POLICIES'], keyof POLICIES> & POLICIES;
 type ReplyWithPolicy<REPLY, POLICIES extends CommandPolicies> = (POLICIES['request'] extends REQUEST_POLICIES['SPECIAL'] ? never : POLICIES['request'] extends null | undefined ? REPLY : unknown extends POLICIES['request'] ? REPLY : POLICIES['response'] extends RESPONSE_POLICIES['SPECIAL'] ? never : POLICIES['response'] extends RESPONSE_POLICIES['ALL_SUCCEEDED' | 'ONE_SUCCEEDED' | 'LOGICAL_AND'] ? REPLY : Array<REPLY>);
 export {};

dist/lib/RESP/types.js

@@ -37,33 +37,1 @@ "use strict";
 };
-const SAME = {
-    transformArguments(key) {
-        return ['GET', key];
-    },
-    transformReply: () => 'default'
-};
-// type SAME_RESP2 = CommandReply<typeof SAME, 2>;
-// type SAME_COMMAND_RESP2 = CommandSignuture<typeof SAME, 2>;
-// type SAME_RESP3 = CommandReply<typeof SAME, 3>;
-// type SAME_COMMAND_RESP3 = CommandSignuture<typeof SAME, 3>;
-// interface Test {
-//   /**
-//    * This is a test
-//    */
-//   a: 'a';
-// }
-// const DIFFERENT = {
-//   transformArguments(key: string): Array<string> {
-//     return ['GET', key];
-//   },
-//   transformReply: {
-//     2: () => null as any as Test,
-//     3: () => '3' as const
-//   }
-// } satisfies Command;
-// type DIFFERENT_RESP2 = CommandReply<typeof DIFFERENT, 2>;
-// type DIFFERENT_COMMAND_RESP2 = CommandSignuture<typeof DIFFERENT, 2>;
-// type DIFFERENT_RESP3 = CommandReply<typeof DIFFERENT, 3>;
-// type DIFFERENT_COMMAND_RESP3 = CommandSignuture<typeof DIFFERENT, 3>;
-// const a = null as any as DIFFERENT_COMMAND_RESP2;
-// const b = await a('a');
-// b.a

dist/lib/RESP/verbatim-string.js

@@ -7,10 +7,5 @@ "use strict";
         super(value);
-        Object.defineProperty(this, "format", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: format
-        });
+        this.format = format;
     }
 }
 exports.VerbatimString = VerbatimString;

package.json

 {
   "name": "@redis/client",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
   "license": "MIT",
@@ -8,34 +8,19 @@ "main": "./dist/index.js",
   "files": [
-    "dist/"
+    "dist/",
+    "!dist/tsconfig.tsbuildinfo"
   ],
   "scripts": {
-    "test": "nyc -r text-summary -r lcov mocha -r source-map-support/register -r ts-node/register './lib/**/*.spec.ts'",
-    "build": "tsc",
-    "lint": "eslint ./*.ts ./lib/**/*.ts",
-    "documentation": "typedoc"
+    "test": "nyc -r text-summary -r lcov mocha -r source-map-support/register -r ts-node/register './lib/**/*.spec.ts'"
   },
   "dependencies": {
     "cluster-key-slot": "1.1.2",
-    "generic-pool": "3.9.0",
-    "yallist": "4.0.0"
+    "generic-pool": "3.9.0"
   },
   "devDependencies": {
-    "@istanbuljs/nyc-config-typescript": "^1.0.2",
     "@redis/test-utils": "*",
-    "@types/node": "^18.16.1",
-    "@types/sinon": "^10.0.14",
-    "@types/yallist": "^4.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.59.1",
-    "@typescript-eslint/parser": "^5.59.1",
-    "eslint": "^8.39.0",
-    "nyc": "^15.1.0",
-    "release-it": "^15.10.1",
-    "sinon": "^15.0.4",
-    "source-map-support": "^0.5.21",
-    "ts-node": "^10.9.1",
-    "typedoc": "^0.24.6",
-    "typescript": "^5.0.4"
+    "@types/sinon": "^10.0.15",
+    "sinon": "^15.2.0"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=16"
   },
@@ -42,0 +27,0 @@ "repository": {

Fixed alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Improved metrics

Dependency count

2

decreased by-33.33%

Dev dependency count

3

decreased by-80%

Number of package files

714

increased by1.71%

Number of medium supply chain risk alerts

2

decreased by-33.33%

Worsened metrics

Total package byte prevSize

658430

decreased by-36.07%

Lines of code

17136

decreased by-28.49%

Dependency changes

• - Removedyallist@4.0.0

• - Removedyallist@4.0.0(transitive)