orcaq 1.0.33 → 1.1.2

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

@@ -0,0 +1,39 @@
+"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 VLINKS_1 = __importDefault(require("./VLINKS"));
+function transformVLinksWithScoresReply(reply) {
+    const layers = [];
+    for (const layer of reply) {
+        const obj = Object.create(null);
+        // Each layer contains alternating element names and scores
+        for (let i = 0; i < layer.length; i += 2) {
+            const element = layer[i];
+            const score = generic_transformers_1.transformDoubleReply[2](layer[i + 1]);
+            obj[element.toString()] = score;
+        }
+        layers.push(obj);
+    }
+    return layers;
+}
+exports.default = {
+    IS_READ_ONLY: VLINKS_1.default.IS_READ_ONLY,
+    /**
+     * Get the connections for each layer of the HNSW graph with similarity scores
+     * @param args - Same parameters as the VLINKS command
+     * @see https://redis.io/commands/vlinks/
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        VLINKS_1.default.parseCommand(...args);
+        parser.push('WITHSCORES');
+    },
+    transformReply: {
+        2: transformVLinksWithScoresReply,
+        3: undefined
+    }
+};
+//# sourceMappingURL=VLINKS_WITHSCORES.js.map

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Retrieve random elements of a vector set
+     *
+     * @param parser - The command parser
+     * @param key - The key of the vector set
+     * @param count - Optional number of elements to return
+     * @see https://redis.io/commands/vrandmember/
+     */
+    parseCommand(parser, key, count) {
+        parser.push('VRANDMEMBER');
+        parser.pushKey(key);
+        if (count !== undefined) {
+            parser.push(count.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=VRANDMEMBER.js.map

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Returns elements in a lexicographical range from a vector set.
+     * Provides a stateless iterator for elements inside a vector set.
+     *
+     * @param parser - The command parser
+     * @param key - The key of the vector set
+     * @param start - The starting point of the lexicographical range.
+     *                Can be a string prefixed with `[` for inclusive (e.g., `[Redis`),
+     *                `(` for exclusive (e.g., `(a7`), or `-` for the minimum element.
+     * @param end - The ending point of the lexicographical range.
+     *              Can be a string prefixed with `[` for inclusive,
+     *              `(` for exclusive, or `+` for the maximum element.
+     * @param count - Optional maximum number of elements to return.
+     *                If negative, returns all elements in the specified range.
+     * @see https://redis.io/commands/vrange/
+     */
+    parseCommand(parser, key, start, end, count) {
+        parser.push('VRANGE');
+        parser.pushKey(key);
+        parser.push(start, end);
+        if (count !== undefined) {
+            parser.push(count.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=VRANGE.js.map

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    /**
+     * Remove an element from a vector set
+     *
+     * @param parser - The command parser
+     * @param key - The key of the vector set
+     * @param element - The name of the element to remove from the vector set
+     * @see https://redis.io/commands/vrem/
+     */
+    parseCommand(parser, key, element) {
+        parser.push('VREM');
+        parser.pushKey(key);
+        parser.push(element);
+    },
+    transformReply: generic_transformers_1.transformBooleanReply
+};
+//# sourceMappingURL=VREM.js.map

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    /**
+     * Set or replace attributes on a vector set element
+     *
+     * @param parser - The command parser
+     * @param key - The key of the vector set
+     * @param element - The name of the element to set attributes for
+     * @param attributes - The attributes to set (as JSON string or object)
+     * @see https://redis.io/commands/vsetattr/
+     */
+    parseCommand(parser, key, element, attributes) {
+        parser.push('VSETATTR');
+        parser.pushKey(key);
+        parser.push(element);
+        if (typeof attributes === 'object' && attributes !== null) {
+            parser.push(JSON.stringify(attributes));
+        }
+        else {
+            parser.push(attributes);
+        }
+    },
+    transformReply: generic_transformers_1.transformBooleanReply
+};
+//# sourceMappingURL=VSETATTR.js.map

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Retrieve elements similar to a given vector or element with optional filtering
+     *
+     * @param parser - The command parser
+     * @param key - The key of the vector set
+     * @param query - The query vector (array of numbers) or element name (string)
+     * @param options - Optional parameters for similarity search
+     * @see https://redis.io/commands/vsim/
+     */
+    parseCommand(parser, key, query, options) {
+        parser.push('VSIM');
+        parser.pushKey(key);
+        if (Array.isArray(query)) {
+            parser.push('VALUES', query.length.toString());
+            for (const value of query) {
+                parser.push((0, generic_transformers_1.transformDoubleArgument)(value));
+            }
+        }
+        else {
+            parser.push('ELE', query);
+        }
+        if (options?.COUNT !== undefined) {
+            parser.push('COUNT', options.COUNT.toString());
+        }
+        if (options?.EPSILON !== undefined) {
+            parser.push('EPSILON', options.EPSILON.toString());
+        }
+        if (options?.EF !== undefined) {
+            parser.push('EF', options.EF.toString());
+        }
+        if (options?.FILTER) {
+            parser.push('FILTER', options.FILTER);
+        }
+        if (options?.['FILTER-EF'] !== undefined) {
+            parser.push('FILTER-EF', options['FILTER-EF'].toString());
+        }
+        if (options?.TRUTH) {
+            parser.push('TRUTH');
+        }
+        if (options?.NOTHREAD) {
+            parser.push('NOTHREAD');
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=VSIM.js.map

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

@@ -0,0 +1,32 @@
+"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 VSIM_1 = __importDefault(require("./VSIM"));
+exports.default = {
+    IS_READ_ONLY: VSIM_1.default.IS_READ_ONLY,
+    /**
+     * Retrieve elements similar to a given vector or element with similarity scores
+     * @param args - Same parameters as the VSIM command
+     * @see https://redis.io/commands/vsim/
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        VSIM_1.default.parseCommand(...args);
+        parser.push('WITHSCORES');
+    },
+    transformReply: {
+        2: (reply) => {
+            const inferred = reply;
+            const members = {};
+            for (let i = 0; i < inferred.length; i += 2) {
+                members[inferred[i].toString()] = generic_transformers_1.transformDoubleReply[2](inferred[i + 1]);
+            }
+            return members;
+        },
+        3: undefined
+    }
+};
+//# sourceMappingURL=VSIM_WITHSCORES.js.map

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Constructs the WAIT command to synchronize with replicas
+     *
+     * @param parser - The command parser
+     * @param numberOfReplicas - Number of replicas that must acknowledge the write
+     * @param timeout - Maximum time to wait in milliseconds
+     * @returns The number of replicas that acknowledged the write
+     * @see https://redis.io/commands/wait/
+     */
+    parseCommand(parser, numberOfReplicas, timeout) {
+        parser.push('WAIT', numberOfReplicas.toString(), timeout.toString());
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=WAIT.js.map

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XACK command to acknowledge the processing of stream messages in a consumer group
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param group - The consumer group name
+     * @param id - One or more message IDs to acknowledge
+     * @returns The number of messages successfully acknowledged
+     * @see https://redis.io/commands/xack/
+     */
+    parseCommand(parser, key, group, id) {
+        parser.push('XACK');
+        parser.pushKey(key);
+        parser.push(group);
+        parser.pushVariadic(id);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=XACK.js.map

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Acknowledges and deletes one or multiple messages for a stream consumer group
+ */
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XACKDEL command to acknowledge and delete one or multiple messages for a stream consumer group
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param group - The consumer group name
+     * @param id - One or more message IDs to acknowledge and delete
+     * @param policy - Policy to apply when deleting entries (optional, defaults to KEEPREF)
+     * @returns Array of integers: -1 (not found), 1 (acknowledged and deleted), 2 (acknowledged with dangling refs)
+     * @see https://redis.io/commands/xackdel/
+     */
+    parseCommand(parser, key, group, id, policy) {
+        parser.push("XACKDEL");
+        parser.pushKey(key);
+        parser.push(group);
+        if (policy) {
+            parser.push(policy);
+        }
+        parser.push("IDS");
+        parser.pushVariadicWithLength(id);
+    },
+    transformReply: undefined,
+};
+//# sourceMappingURL=XACKDEL.js.map

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXAddArguments = void 0;
+/**
+ * Parses arguments for the XADD command
+ *
+ * @param optional - Optional command modifier (e.g., NOMKSTREAM)
+ * @param parser - The command parser
+ * @param key - The stream key
+ * @param id - Message ID (* for auto-generation)
+ * @param message - Key-value pairs representing the message fields
+ * @param options - Additional options for reference tracking, idempotency, and trimming
+ */
+function parseXAddArguments(optional, parser, key, id, message, options) {
+    parser.push('XADD');
+    parser.pushKey(key);
+    if (optional) {
+        parser.push(optional);
+    }
+    // Reference tracking policy (KEEPREF | DELREF | ACKED)
+    if (options?.policy) {
+        parser.push(options.policy);
+    }
+    // Idempotency options (IDMPAUTO or IDMP)
+    if (options?.IDMPAUTO) {
+        parser.push('IDMPAUTO', options.IDMPAUTO.pid);
+    }
+    else if (options?.IDMP) {
+        parser.push('IDMP', options.IDMP.pid, options.IDMP.iid);
+    }
+    // Trimming options
+    if (options?.TRIM) {
+        if (options.TRIM.strategy) {
+            parser.push(options.TRIM.strategy);
+        }
+        if (options.TRIM.strategyModifier) {
+            parser.push(options.TRIM.strategyModifier);
+        }
+        parser.push(options.TRIM.threshold.toString());
+        if (options.TRIM.limit) {
+            parser.push('LIMIT', options.TRIM.limit.toString());
+        }
+        if (options.TRIM.policy) {
+            parser.push(options.TRIM.policy);
+        }
+    }
+    parser.push(id);
+    for (const [key, value] of Object.entries(message)) {
+        parser.push(key, value);
+    }
+}
+exports.parseXAddArguments = parseXAddArguments;
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XADD command to append a new entry to a stream
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param id - Message ID (* for auto-generation)
+     * @param message - Key-value pairs representing the message fields
+     * @param options - Additional options for stream trimming
+     * @returns The ID of the added entry
+     * @see https://redis.io/commands/xadd/
+     */
+    parseCommand(...args) {
+        return parseXAddArguments(undefined, ...args);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=XADD.js.map

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const XADD_1 = require("./XADD");
+/**
+ * Command for adding entries to an existing stream without creating it if it doesn't exist
+ */
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XADD command with NOMKSTREAM option to append a new entry to an existing stream
+     *
+     * @param args - Arguments tuple containing parser, key, id, message, and options
+     * @returns The ID of the added entry, or null if the stream doesn't exist
+     * @see https://redis.io/commands/xadd/
+     */
+    parseCommand(...args) {
+        return (0, XADD_1.parseXAddArguments)('NOMKSTREAM', ...args);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=XADD_NOMKSTREAM.js.map

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XAUTOCLAIM command to automatically claim pending messages in a consumer group
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param group - The consumer group name
+     * @param consumer - The consumer name that will claim the messages
+     * @param minIdleTime - Minimum idle time in milliseconds for a message to be claimed
+     * @param start - Message ID to start scanning from
+     * @param options - Additional options for the claim operation
+     * @returns Object containing nextId, claimed messages, and list of deleted message IDs
+     * @see https://redis.io/commands/xautoclaim/
+     */
+    parseCommand(parser, key, group, consumer, minIdleTime, start, options) {
+        parser.push('XAUTOCLAIM');
+        parser.pushKey(key);
+        parser.push(group, consumer, minIdleTime.toString(), start);
+        if (options?.COUNT) {
+            parser.push('COUNT', options.COUNT.toString());
+        }
+    },
+    /**
+     * Transforms the raw XAUTOCLAIM reply into a structured object
+     *
+     * @param reply - Raw reply from Redis
+     * @param preserve - Preserve options (unused)
+     * @param typeMapping - Type mapping for message fields
+     * @returns Structured object containing nextId, messages, and deletedMessages
+     */
+    transformReply(reply, preserve, typeMapping) {
+        return {
+            nextId: reply[0],
+            messages: reply[1].map(generic_transformers_1.transformStreamMessageNullReply.bind(undefined, typeMapping)),
+            deletedMessages: reply[2]
+        };
+    }
+};
+//# sourceMappingURL=XAUTOCLAIM.js.map

package/.output/server/node_modules/@redis/client/dist/lib/commands/XAUTOCLAIM_JUSTID.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 XAUTOCLAIM_1 = __importDefault(require("./XAUTOCLAIM"));
+exports.default = {
+    IS_READ_ONLY: XAUTOCLAIM_1.default.IS_READ_ONLY,
+    /**
+     * Constructs the XAUTOCLAIM command with JUSTID option to get only message IDs
+     *
+     * @param args - Same parameters as XAUTOCLAIM command
+     * @returns Object containing nextId and arrays of claimed and deleted message IDs
+     * @see https://redis.io/commands/xautoclaim/
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        XAUTOCLAIM_1.default.parseCommand(...args);
+        parser.push('JUSTID');
+    },
+    /**
+     * Transforms the raw XAUTOCLAIM JUSTID reply into a structured object
+     *
+     * @param reply - Raw reply from Redis
+     * @returns Structured object containing nextId, message IDs, and deleted message IDs
+     */
+    transformReply(reply) {
+        return {
+            nextId: reply[0],
+            messages: reply[1],
+            deletedMessages: reply[2]
+        };
+    }
+};
+//# sourceMappingURL=XAUTOCLAIM_JUSTID.js.map

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Configures the idempotency parameters for a stream's IDMP map.
+     * Sets how long Redis remembers each iid and the maximum number of iids to track.
+     * This command clears the existing IDMP map (Redis forgets all previously stored iids),
+     * but only if the configuration value actually changes.
+     *
+     * @param parser - The command parser
+     * @param key - The name of the stream
+     * @param options - Optional idempotency configuration parameters
+     * @returns 'OK' on success
+     */
+    parseCommand(parser, key, options) {
+        parser.push('XCFGSET');
+        parser.pushKey(key);
+        if (options?.IDMP_DURATION !== undefined) {
+            parser.push('IDMP-DURATION', options.IDMP_DURATION.toString());
+        }
+        if (options?.IDMP_MAXSIZE !== undefined) {
+            parser.push('IDMP-MAXSIZE', options.IDMP_MAXSIZE.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=XCFGSET.js.map

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("./generic-transformers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XCLAIM command to claim pending messages in a consumer group
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param group - The consumer group name
+     * @param consumer - The consumer name that will claim the messages
+     * @param minIdleTime - Minimum idle time in milliseconds for a message to be claimed
+     * @param id - One or more message IDs to claim
+     * @param options - Additional options for the claim operation
+     * @returns Array of claimed messages
+     * @see https://redis.io/commands/xclaim/
+     */
+    parseCommand(parser, key, group, consumer, minIdleTime, id, options) {
+        parser.push('XCLAIM');
+        parser.pushKey(key);
+        parser.push(group, consumer, minIdleTime.toString());
+        parser.pushVariadic(id);
+        if (options?.IDLE !== undefined) {
+            parser.push('IDLE', options.IDLE.toString());
+        }
+        if (options?.TIME !== undefined) {
+            parser.push('TIME', (options.TIME instanceof Date ? options.TIME.getTime() : options.TIME).toString());
+        }
+        if (options?.RETRYCOUNT !== undefined) {
+            parser.push('RETRYCOUNT', options.RETRYCOUNT.toString());
+        }
+        if (options?.FORCE) {
+            parser.push('FORCE');
+        }
+        if (options?.LASTID !== undefined) {
+            parser.push('LASTID', options.LASTID);
+        }
+    },
+    /**
+     * Transforms the raw XCLAIM reply into an array of messages
+     *
+     * @param reply - Raw reply from Redis
+     * @param preserve - Preserve options (unused)
+     * @param typeMapping - Type mapping for message fields
+     * @returns Array of claimed messages with their fields
+     */
+    transformReply(reply, preserve, typeMapping) {
+        return reply.map(generic_transformers_1.transformStreamMessageNullReply.bind(undefined, typeMapping));
+    }
+};
+//# sourceMappingURL=XCLAIM.js.map

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

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const XCLAIM_1 = __importDefault(require("./XCLAIM"));
+/**
+ * Command variant for XCLAIM that returns only message IDs
+ */
+exports.default = {
+    IS_READ_ONLY: XCLAIM_1.default.IS_READ_ONLY,
+    /**
+     * Constructs the XCLAIM command with JUSTID option to get only message IDs
+     *
+     * @param args - Same parameters as XCLAIM command
+     * @returns Array of successfully claimed message IDs
+     * @see https://redis.io/commands/xclaim/
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        XCLAIM_1.default.parseCommand(...args);
+        parser.push('JUSTID');
+    },
+    /**
+     * Transforms the XCLAIM JUSTID reply into an array of message IDs
+     *
+     * @returns Array of claimed message IDs
+     */
+    transformReply: undefined
+};
+//# sourceMappingURL=XCLAIM_JUSTID.js.map

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Command for removing messages from a stream
+ */
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XDEL command to remove one or more messages from a stream
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param id - One or more message IDs to delete
+     * @returns The number of messages actually deleted
+     * @see https://redis.io/commands/xdel/
+     */
+    parseCommand(parser, key, id) {
+        parser.push('XDEL');
+        parser.pushKey(key);
+        parser.pushVariadic(id);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=XDEL.js.map

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Deletes one or multiple entries from the stream
+ */
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Constructs the XDELEX command to delete one or multiple entries from the stream
+     *
+     * @param parser - The command parser
+     * @param key - The stream key
+     * @param id - One or more message IDs to delete
+     * @param policy - Policy to apply when deleting entries (optional, defaults to KEEPREF)
+     * @returns Array of integers: -1 (not found), 1 (deleted), 2 (dangling refs)
+     * @see https://redis.io/commands/xdelex/
+     */
+    parseCommand(parser, key, id, policy) {
+        parser.push("XDELEX");
+        parser.pushKey(key);
+        if (policy) {
+            parser.push(policy);
+        }
+        parser.push("IDS");
+        parser.pushVariadicWithLength(id);
+    },
+    transformReply: undefined,
+};
+//# sourceMappingURL=XDELEX.js.map