orcaq 1.1.1 → 1.1.3

package/.output/server/node_modules/@redis/client/dist/lib/commands/BZPOPMAX.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Removes and returns the member with the highest score in a sorted set, or blocks until one is available
+     * @param parser - The Redis command parser
+     * @param keys - Key of the sorted set, or array of keys to try sequentially
+     * @param timeout - Maximum seconds to block, 0 to block indefinitely
+     */
+    parseCommand(parser, keys, timeout) {
+        parser.push('BZPOPMAX');
+        parser.pushKeys(keys);
+        parser.push(timeout.toString());
+    },
+    transformReply: {
+        2(reply, preserve, typeMapping) {
+            return reply === null ? null : {
+                key: reply[0],
+                value: reply[1],
+                score: generic_transformers_1.transformDoubleReply[2](reply[2], preserve, typeMapping)
+            };
+        },
+        3(reply) {
+            return reply === null ? null : {
+                key: reply[0],
+                value: reply[1],
+                score: reply[2]
+            };
+        }
+    }
+};
+//# sourceMappingURL=BZPOPMAX.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/BZPOPMIN.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BZPOPMAX_1 = __importDefault(require("./BZPOPMAX"));
+exports.default = {
+    IS_READ_ONLY: BZPOPMAX_1.default.IS_READ_ONLY,
+    /**
+     * Removes and returns the member with the lowest score in a sorted set, or blocks until one is available
+     * @param parser - The Redis command parser
+     * @param keys - Key of the sorted set, or array of keys to try sequentially
+     * @param timeout - Maximum seconds to block, 0 to block indefinitely
+     */
+    parseCommand(parser, keys, timeout) {
+        parser.push('BZPOPMIN');
+        parser.pushKeys(keys);
+        parser.push(timeout.toString());
+    },
+    transformReply: BZPOPMAX_1.default.transformReply
+};
+//# sourceMappingURL=BZPOPMIN.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_CACHING.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Instructs the server about tracking or not keys in the next request
+     * @param parser - The Redis command parser
+     * @param value - Whether to enable (true) or disable (false) tracking
+     */
+    parseCommand(parser, value) {
+        parser.push('CLIENT', 'CACHING', value ? 'YES' : 'NO');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_CACHING.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_GETNAME.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the name of the current connection
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLIENT', 'GETNAME');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_GETNAME.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_GETREDIR.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the ID of the client to which the current client is redirecting tracking notifications
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLIENT', 'GETREDIR');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_GETREDIR.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_ID.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the client ID for the current connection
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLIENT', 'ID');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_ID.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_INFO.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CLIENT_INFO_REGEX = /([^\s=]+)=([^\s]*)/g;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns information and statistics about the current client connection
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLIENT', 'INFO');
+    },
+    transformReply(rawReply) {
+        const map = {};
+        for (const item of rawReply.toString().matchAll(CLIENT_INFO_REGEX)) {
+            map[item[1]] = item[2];
+        }
+        const reply = {
+            id: Number(map.id),
+            addr: map.addr,
+            fd: Number(map.fd),
+            name: map.name,
+            age: Number(map.age),
+            idle: Number(map.idle),
+            flags: map.flags,
+            db: Number(map.db),
+            sub: Number(map.sub),
+            psub: Number(map.psub),
+            multi: Number(map.multi),
+            qbuf: Number(map.qbuf),
+            qbufFree: Number(map['qbuf-free']),
+            argvMem: Number(map['argv-mem']),
+            obl: Number(map.obl),
+            oll: Number(map.oll),
+            omem: Number(map.omem),
+            totMem: Number(map['tot-mem']),
+            events: map.events,
+            cmd: map.cmd,
+            user: map.user,
+            libName: map['lib-name'],
+            libVer: map['lib-ver']
+        };
+        if (map.laddr !== undefined) {
+            reply.laddr = map.laddr;
+        }
+        if (map.redir !== undefined) {
+            reply.redir = Number(map.redir);
+        }
+        if (map.ssub !== undefined) {
+            reply.ssub = Number(map.ssub);
+        }
+        if (map['multi-mem'] !== undefined) {
+            reply.multiMem = Number(map['multi-mem']);
+        }
+        if (map.resp !== undefined) {
+            reply.resp = Number(map.resp);
+        }
+        return reply;
+    }
+};
+//# sourceMappingURL=CLIENT_INFO.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_KILL.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIENT_KILL_FILTERS = void 0;
+exports.CLIENT_KILL_FILTERS = {
+    ADDRESS: 'ADDR',
+    LOCAL_ADDRESS: 'LADDR',
+    ID: 'ID',
+    TYPE: 'TYPE',
+    USER: 'USER',
+    SKIP_ME: 'SKIPME',
+    MAXAGE: 'MAXAGE'
+};
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Closes client connections matching the specified filters
+     * @param parser - The Redis command parser
+     * @param filters - One or more filters to match client connections to kill
+     */
+    parseCommand(parser, filters) {
+        parser.push('CLIENT', 'KILL');
+        if (Array.isArray(filters)) {
+            for (const filter of filters) {
+                pushFilter(parser, filter);
+            }
+        }
+        else {
+            pushFilter(parser, filters);
+        }
+    },
+    transformReply: undefined
+};
+function pushFilter(parser, filter) {
+    if (filter === exports.CLIENT_KILL_FILTERS.SKIP_ME) {
+        parser.push('SKIPME');
+        return;
+    }
+    parser.push(filter.filter);
+    switch (filter.filter) {
+        case exports.CLIENT_KILL_FILTERS.ADDRESS:
+            parser.push(filter.address);
+            break;
+        case exports.CLIENT_KILL_FILTERS.LOCAL_ADDRESS:
+            parser.push(filter.localAddress);
+            break;
+        case exports.CLIENT_KILL_FILTERS.ID:
+            parser.push(typeof filter.id === 'number' ?
+                filter.id.toString() :
+                filter.id);
+            break;
+        case exports.CLIENT_KILL_FILTERS.TYPE:
+            parser.push(filter.type);
+            break;
+        case exports.CLIENT_KILL_FILTERS.USER:
+            parser.push(filter.username);
+            break;
+        case exports.CLIENT_KILL_FILTERS.SKIP_ME:
+            parser.push(filter.skipMe ? 'yes' : 'no');
+            break;
+        case exports.CLIENT_KILL_FILTERS.MAXAGE:
+            parser.push(filter.maxAge.toString());
+            break;
+    }
+}
+//# sourceMappingURL=CLIENT_KILL.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_LIST.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CLIENT_INFO_1 = __importDefault(require("./CLIENT_INFO"));
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns information about all client connections. Can be filtered by type or ID
+     * @param parser - The Redis command parser
+     * @param filter - Optional filter to return only specific client types or IDs
+     */
+    parseCommand(parser, filter) {
+        parser.push('CLIENT', 'LIST');
+        if (filter) {
+            if (filter.TYPE !== undefined) {
+                parser.push('TYPE', filter.TYPE);
+            }
+            else {
+                parser.push('ID');
+                parser.pushVariadic(filter.ID);
+            }
+        }
+    },
+    transformReply(rawReply) {
+        const split = rawReply.toString().split('\n'), length = split.length - 1, reply = [];
+        for (let i = 0; i < length; i++) {
+            reply.push(CLIENT_INFO_1.default.transformReply(split[i]));
+        }
+        return reply;
+    }
+};
+//# sourceMappingURL=CLIENT_LIST.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_NO-EVICT.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Controls whether to prevent the client's connections from being evicted
+     * @param parser - The Redis command parser
+     * @param value - Whether to enable (true) or disable (false) the no-evict mode
+     */
+    parseCommand(parser, value) {
+        parser.push('CLIENT', 'NO-EVICT', value ? 'ON' : 'OFF');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_NO-EVICT.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_NO-TOUCH.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Controls whether to prevent the client from touching the LRU/LFU of keys
+     * @param parser - The Redis command parser
+     * @param value - Whether to enable (true) or disable (false) the no-touch mode
+     */
+    parseCommand(parser, value) {
+        parser.push('CLIENT', 'NO-TOUCH', value ? 'ON' : 'OFF');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_NO-TOUCH.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_PAUSE.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Stops the server from processing client commands for the specified duration
+     * @param parser - The Redis command parser
+     * @param timeout - Time in milliseconds to pause command processing
+     * @param mode - Optional mode: 'WRITE' to pause only write commands, 'ALL' to pause all commands
+     */
+    parseCommand(parser, timeout, mode) {
+        parser.push('CLIENT', 'PAUSE', timeout.toString());
+        if (mode) {
+            parser.push(mode);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_PAUSE.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_SETNAME.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Assigns a name to the current connection
+     * @param parser - The Redis command parser
+     * @param name - The name to assign to the connection
+     */
+    parseCommand(parser, name) {
+        parser.push('CLIENT', 'SETNAME', name);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_SETNAME.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_TRACKING.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Controls server-assisted client side caching for the current connection
+     * @param parser - The Redis command parser
+     * @param mode - Whether to enable (true) or disable (false) tracking
+     * @param options - Optional configuration including REDIRECT, BCAST, PREFIX, OPTIN, OPTOUT, and NOLOOP options
+     */
+    parseCommand(parser, mode, options) {
+        parser.push('CLIENT', 'TRACKING', mode ? 'ON' : 'OFF');
+        if (mode) {
+            if (options?.REDIRECT) {
+                parser.push('REDIRECT', options.REDIRECT.toString());
+            }
+            if (isBroadcast(options)) {
+                parser.push('BCAST');
+                if (options?.PREFIX) {
+                    if (Array.isArray(options.PREFIX)) {
+                        for (const prefix of options.PREFIX) {
+                            parser.push('PREFIX', prefix);
+                        }
+                    }
+                    else {
+                        parser.push('PREFIX', options.PREFIX);
+                    }
+                }
+            }
+            else if (isOptIn(options)) {
+                parser.push('OPTIN');
+            }
+            else if (isOptOut(options)) {
+                parser.push('OPTOUT');
+            }
+            if (options?.NOLOOP) {
+                parser.push('NOLOOP');
+            }
+        }
+    },
+    transformReply: undefined
+};
+function isBroadcast(options) {
+    return options?.BCAST === true;
+}
+function isOptIn(options) {
+    return options?.OPTIN === true;
+}
+function isOptOut(options) {
+    return options?.OPTOUT === true;
+}
+//# sourceMappingURL=CLIENT_TRACKING.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_TRACKINGINFO.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns information about the current connection's key tracking state
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLIENT', 'TRACKINGINFO');
+    },
+    transformReply: {
+        2: (reply) => ({
+            flags: reply[1],
+            redirect: reply[3],
+            prefixes: reply[5]
+        }),
+        3: undefined
+    }
+};
+//# sourceMappingURL=CLIENT_TRACKINGINFO.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLIENT_UNPAUSE.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Resumes processing of client commands after a CLIENT PAUSE
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLIENT', 'UNPAUSE');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLIENT_UNPAUSE.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_ADDSLOTS.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Assigns hash slots to the current node in a Redis Cluster
+     * @param parser - The Redis command parser
+     * @param slots - One or more hash slots to be assigned
+     */
+    parseCommand(parser, slots) {
+        parser.push('CLUSTER', 'ADDSLOTS');
+        parser.pushVariadicNumber(slots);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_ADDSLOTS.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_ADDSLOTSRANGE.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Assigns hash slot ranges to the current node in a Redis Cluster
+     * @param parser - The Redis command parser
+     * @param ranges - One or more slot ranges to be assigned, each specified as [start, end]
+     */
+    parseCommand(parser, ranges) {
+        parser.push('CLUSTER', 'ADDSLOTSRANGE');
+        (0, generic_transformers_1.parseSlotRangesArguments)(parser, ranges);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_ADDSLOTSRANGE.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_BUMPEPOCH.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Advances the cluster config epoch
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLUSTER', 'BUMPEPOCH');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_BUMPEPOCH.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_COUNT-FAILURE-REPORTS.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the number of failure reports for a given node
+     * @param parser - The Redis command parser
+     * @param nodeId - The ID of the node to check
+     */
+    parseCommand(parser, nodeId) {
+        parser.push('CLUSTER', 'COUNT-FAILURE-REPORTS', nodeId);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_COUNT-FAILURE-REPORTS.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_COUNTKEYSINSLOT.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns the number of keys in the specified hash slot
+     * @param parser - The Redis command parser
+     * @param slot - The hash slot to check
+     */
+    parseCommand(parser, slot) {
+        parser.push('CLUSTER', 'COUNTKEYSINSLOT', slot.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_COUNTKEYSINSLOT.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_DELSLOTS.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Removes hash slots from the current node in a Redis Cluster
+     * @param parser - The Redis command parser
+     * @param slots - One or more hash slots to be removed
+     */
+    parseCommand(parser, slots) {
+        parser.push('CLUSTER', 'DELSLOTS');
+        parser.pushVariadicNumber(slots);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_DELSLOTS.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_DELSLOTSRANGE.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Removes hash slot ranges from the current node in a Redis Cluster
+     * @param parser - The Redis command parser
+     * @param ranges - One or more slot ranges to be removed, each specified as [start, end]
+     */
+    parseCommand(parser, ranges) {
+        parser.push('CLUSTER', 'DELSLOTSRANGE');
+        (0, generic_transformers_1.parseSlotRangesArguments)(parser, ranges);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_DELSLOTSRANGE.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_FAILOVER.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAILOVER_MODES = void 0;
+exports.FAILOVER_MODES = {
+    FORCE: 'FORCE',
+    TAKEOVER: 'TAKEOVER'
+};
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Forces a replica to perform a manual failover of its master
+     * @param parser - The Redis command parser
+     * @param options - Optional configuration with FORCE or TAKEOVER mode
+     */
+    parseCommand(parser, options) {
+        parser.push('CLUSTER', 'FAILOVER');
+        if (options?.mode) {
+            parser.push(options.mode);
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_FAILOVER.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_FLUSHSLOTS.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Deletes all hash slots from the current node in a Redis Cluster
+     * @param parser - The Redis command parser
+     */
+    parseCommand(parser) {
+        parser.push('CLUSTER', 'FLUSHSLOTS');
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_FLUSHSLOTS.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_FORGET.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Removes a node from the cluster
+     * @param parser - The Redis command parser
+     * @param nodeId - The ID of the node to remove
+     */
+    parseCommand(parser, nodeId) {
+        parser.push('CLUSTER', 'FORGET', nodeId);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_FORGET.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/CLUSTER_GETKEYSINSLOT.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Returns a number of keys from the specified hash slot
+     * @param parser - The Redis command parser
+     * @param slot - The hash slot to get keys from
+     * @param count - Maximum number of keys to return
+     */
+    parseCommand(parser, slot, count) {
+        parser.push('CLUSTER', 'GETKEYSINSLOT', slot.toString(), count.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CLUSTER_GETKEYSINSLOT.js.map