orcaq 1.1.1 → 1.1.2

package/.output/server/node_modules/@redis/search/dist/lib/commands/index.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const _LIST_1 = __importDefault(require("./_LIST"));
+const ALTER_1 = __importDefault(require("./ALTER"));
+const AGGREGATE_WITHCURSOR_1 = __importDefault(require("./AGGREGATE_WITHCURSOR"));
+const AGGREGATE_1 = __importDefault(require("./AGGREGATE"));
+const ALIASADD_1 = __importDefault(require("./ALIASADD"));
+const ALIASDEL_1 = __importDefault(require("./ALIASDEL"));
+const ALIASUPDATE_1 = __importDefault(require("./ALIASUPDATE"));
+const CONFIG_GET_1 = __importDefault(require("./CONFIG_GET"));
+const CONFIG_SET_1 = __importDefault(require("./CONFIG_SET"));
+const CREATE_1 = __importDefault(require("./CREATE"));
+const CURSOR_DEL_1 = __importDefault(require("./CURSOR_DEL"));
+const CURSOR_READ_1 = __importDefault(require("./CURSOR_READ"));
+const DICTADD_1 = __importDefault(require("./DICTADD"));
+const DICTDEL_1 = __importDefault(require("./DICTDEL"));
+const DICTDUMP_1 = __importDefault(require("./DICTDUMP"));
+const DROPINDEX_1 = __importDefault(require("./DROPINDEX"));
+const EXPLAIN_1 = __importDefault(require("./EXPLAIN"));
+const EXPLAINCLI_1 = __importDefault(require("./EXPLAINCLI"));
+const HYBRID_1 = __importDefault(require("./HYBRID"));
+const INFO_1 = __importDefault(require("./INFO"));
+const PROFILE_SEARCH_1 = __importDefault(require("./PROFILE_SEARCH"));
+const PROFILE_AGGREGATE_1 = __importDefault(require("./PROFILE_AGGREGATE"));
+const SEARCH_NOCONTENT_1 = __importDefault(require("./SEARCH_NOCONTENT"));
+const SEARCH_1 = __importDefault(require("./SEARCH"));
+const SPELLCHECK_1 = __importDefault(require("./SPELLCHECK"));
+const SUGADD_1 = __importDefault(require("./SUGADD"));
+const SUGDEL_1 = __importDefault(require("./SUGDEL"));
+const SUGGET_WITHPAYLOADS_1 = __importDefault(require("./SUGGET_WITHPAYLOADS"));
+const SUGGET_WITHSCORES_WITHPAYLOADS_1 = __importDefault(require("./SUGGET_WITHSCORES_WITHPAYLOADS"));
+const SUGGET_WITHSCORES_1 = __importDefault(require("./SUGGET_WITHSCORES"));
+const SUGGET_1 = __importDefault(require("./SUGGET"));
+const SUGLEN_1 = __importDefault(require("./SUGLEN"));
+const SYNDUMP_1 = __importDefault(require("./SYNDUMP"));
+const SYNUPDATE_1 = __importDefault(require("./SYNUPDATE"));
+const TAGVALS_1 = __importDefault(require("./TAGVALS"));
+exports.default = {
+    _LIST: _LIST_1.default,
+    _list: _LIST_1.default,
+    ALTER: ALTER_1.default,
+    alter: ALTER_1.default,
+    AGGREGATE_WITHCURSOR: AGGREGATE_WITHCURSOR_1.default,
+    aggregateWithCursor: AGGREGATE_WITHCURSOR_1.default,
+    AGGREGATE: AGGREGATE_1.default,
+    aggregate: AGGREGATE_1.default,
+    ALIASADD: ALIASADD_1.default,
+    aliasAdd: ALIASADD_1.default,
+    ALIASDEL: ALIASDEL_1.default,
+    aliasDel: ALIASDEL_1.default,
+    ALIASUPDATE: ALIASUPDATE_1.default,
+    aliasUpdate: ALIASUPDATE_1.default,
+    /**
+     * @deprecated Redis >=8 uses the standard CONFIG command
+     */
+    CONFIG_GET: CONFIG_GET_1.default,
+    /**
+     * @deprecated Redis >=8 uses the standard CONFIG command
+     */
+    configGet: CONFIG_GET_1.default,
+    /**
+     * @deprecated Redis >=8 uses the standard CONFIG command
+     */
+    CONFIG_SET: CONFIG_SET_1.default,
+    /**
+     * @deprecated Redis >=8 uses the standard CONFIG command
+     */
+    configSet: CONFIG_SET_1.default,
+    CREATE: CREATE_1.default,
+    create: CREATE_1.default,
+    CURSOR_DEL: CURSOR_DEL_1.default,
+    cursorDel: CURSOR_DEL_1.default,
+    CURSOR_READ: CURSOR_READ_1.default,
+    cursorRead: CURSOR_READ_1.default,
+    DICTADD: DICTADD_1.default,
+    dictAdd: DICTADD_1.default,
+    DICTDEL: DICTDEL_1.default,
+    dictDel: DICTDEL_1.default,
+    DICTDUMP: DICTDUMP_1.default,
+    dictDump: DICTDUMP_1.default,
+    DROPINDEX: DROPINDEX_1.default,
+    dropIndex: DROPINDEX_1.default,
+    EXPLAIN: EXPLAIN_1.default,
+    explain: EXPLAIN_1.default,
+    EXPLAINCLI: EXPLAINCLI_1.default,
+    explainCli: EXPLAINCLI_1.default,
+    HYBRID: HYBRID_1.default,
+    hybrid: HYBRID_1.default,
+    INFO: INFO_1.default,
+    info: INFO_1.default,
+    PROFILESEARCH: PROFILE_SEARCH_1.default,
+    profileSearch: PROFILE_SEARCH_1.default,
+    PROFILEAGGREGATE: PROFILE_AGGREGATE_1.default,
+    profileAggregate: PROFILE_AGGREGATE_1.default,
+    SEARCH_NOCONTENT: SEARCH_NOCONTENT_1.default,
+    searchNoContent: SEARCH_NOCONTENT_1.default,
+    SEARCH: SEARCH_1.default,
+    search: SEARCH_1.default,
+    SPELLCHECK: SPELLCHECK_1.default,
+    spellCheck: SPELLCHECK_1.default,
+    SUGADD: SUGADD_1.default,
+    sugAdd: SUGADD_1.default,
+    SUGDEL: SUGDEL_1.default,
+    sugDel: SUGDEL_1.default,
+    SUGGET_WITHPAYLOADS: SUGGET_WITHPAYLOADS_1.default,
+    sugGetWithPayloads: SUGGET_WITHPAYLOADS_1.default,
+    SUGGET_WITHSCORES_WITHPAYLOADS: SUGGET_WITHSCORES_WITHPAYLOADS_1.default,
+    sugGetWithScoresWithPayloads: SUGGET_WITHSCORES_WITHPAYLOADS_1.default,
+    SUGGET_WITHSCORES: SUGGET_WITHSCORES_1.default,
+    sugGetWithScores: SUGGET_WITHSCORES_1.default,
+    SUGGET: SUGGET_1.default,
+    sugGet: SUGGET_1.default,
+    SUGLEN: SUGLEN_1.default,
+    sugLen: SUGLEN_1.default,
+    SYNDUMP: SYNDUMP_1.default,
+    synDump: SYNDUMP_1.default,
+    SYNUPDATE: SYNUPDATE_1.default,
+    synUpdate: SYNUPDATE_1.default,
+    TAGVALS: TAGVALS_1.default,
+    tagVals: TAGVALS_1.default
+};
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redis/search/dist/lib/dialect/default.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_DIALECT = void 0;
+exports.DEFAULT_DIALECT = '2';
+//# sourceMappingURL=default.js.map

package/.output/server/node_modules/@redis/search/dist/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FT_AGGREGATE_STEPS = exports.FT_AGGREGATE_GROUP_BY_REDUCERS = exports.SCHEMA_VECTOR_FIELD_ALGORITHM = exports.SCHEMA_TEXT_FIELD_PHONETIC = exports.SCHEMA_FIELD_TYPE = exports.REDISEARCH_LANGUAGE = exports.default = void 0;
+var commands_1 = require("./commands");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(commands_1).default; } });
+var CREATE_1 = require("./commands/CREATE");
+Object.defineProperty(exports, "REDISEARCH_LANGUAGE", { enumerable: true, get: function () { return CREATE_1.REDISEARCH_LANGUAGE; } });
+Object.defineProperty(exports, "SCHEMA_FIELD_TYPE", { enumerable: true, get: function () { return CREATE_1.SCHEMA_FIELD_TYPE; } });
+Object.defineProperty(exports, "SCHEMA_TEXT_FIELD_PHONETIC", { enumerable: true, get: function () { return CREATE_1.SCHEMA_TEXT_FIELD_PHONETIC; } });
+Object.defineProperty(exports, "SCHEMA_VECTOR_FIELD_ALGORITHM", { enumerable: true, get: function () { return CREATE_1.SCHEMA_VECTOR_FIELD_ALGORITHM; } });
+var AGGREGATE_1 = require("./commands/AGGREGATE");
+Object.defineProperty(exports, "FT_AGGREGATE_GROUP_BY_REDUCERS", { enumerable: true, get: function () { return AGGREGATE_1.FT_AGGREGATE_GROUP_BY_REDUCERS; } });
+Object.defineProperty(exports, "FT_AGGREGATE_STEPS", { enumerable: true, get: function () { return AGGREGATE_1.FT_AGGREGATE_STEPS; } });
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@redis/search/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@redis/search",
+  "version": "5.12.1",
+  "license": "MIT",
+  "main": "./dist/lib/index.js",
+  "types": "./dist/lib/index.d.ts",
+  "files": [
+    "dist/",
+    "!dist/tsconfig.tsbuildinfo"
+  ],
+  "scripts": {
+    "test": "nyc -r text-summary -r lcov mocha -r tsx --reporter mocha-multi-reporters --reporter-options configFile=mocha-multi-reporter-config.json --exit  './lib/**/*.spec.ts'",
+    "test-sourcemap": "mocha -r ts-node/register/transpile-only './lib/**/*.spec.ts'",
+    "release": "release-it"
+  },
+  "peerDependencies": {
+    "@redis/client": "^5.12.1"
+  },
+  "devDependencies": {
+    "@redis/test-utils": "*"
+  },
+  "engines": {
+    "node": ">= 18.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/redis/node-redis.git"
+  },
+  "bugs": {
+    "url": "https://github.com/redis/node-redis/issues"
+  },
+  "homepage": "https://github.com/redis/node-redis/tree/master/packages/search",
+  "keywords": [
+    "redis",
+    "RediSearch"
+  ]
+}

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/ADD.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Creates or appends a sample to a time series
+     * @param parser - The command parser
+     * @param key - The key name for the time series
+     * @param timestamp - The timestamp of the sample
+     * @param value - The value of the sample
+     * @param options - Optional configuration parameters
+     */
+    parseCommand(parser, key, timestamp, value, options) {
+        parser.push('TS.ADD');
+        parser.pushKey(key);
+        parser.push((0, helpers_1.transformTimestampArgument)(timestamp), value.toString());
+        (0, helpers_1.parseRetentionArgument)(parser, options?.RETENTION);
+        (0, helpers_1.parseEncodingArgument)(parser, options?.ENCODING);
+        (0, helpers_1.parseChunkSizeArgument)(parser, options?.CHUNK_SIZE);
+        if (options?.ON_DUPLICATE) {
+            parser.push('ON_DUPLICATE', options.ON_DUPLICATE);
+        }
+        (0, helpers_1.parseLabelsArgument)(parser, options?.LABELS);
+        (0, helpers_1.parseIgnoreArgument)(parser, options?.IGNORE);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ADD.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/ALTER.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Alters the configuration of an existing time series
+     * @param parser - The command parser
+     * @param key - The key name for the time series
+     * @param options - Configuration parameters to alter
+     */
+    parseCommand(parser, key, options) {
+        parser.push('TS.ALTER');
+        parser.pushKey(key);
+        (0, helpers_1.parseRetentionArgument)(parser, options?.RETENTION);
+        (0, helpers_1.parseChunkSizeArgument)(parser, options?.CHUNK_SIZE);
+        (0, helpers_1.parseDuplicatePolicy)(parser, options?.DUPLICATE_POLICY);
+        (0, helpers_1.parseLabelsArgument)(parser, options?.LABELS);
+        (0, helpers_1.parseIgnoreArgument)(parser, options?.IGNORE);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=ALTER.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/CREATE.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Creates a new time series
+     * @param parser - The command parser
+     * @param key - The key name for the new time series
+     * @param options - Optional configuration parameters
+     */
+    parseCommand(parser, key, options) {
+        parser.push('TS.CREATE');
+        parser.pushKey(key);
+        (0, helpers_1.parseRetentionArgument)(parser, options?.RETENTION);
+        (0, helpers_1.parseEncodingArgument)(parser, options?.ENCODING);
+        (0, helpers_1.parseChunkSizeArgument)(parser, options?.CHUNK_SIZE);
+        (0, helpers_1.parseDuplicatePolicy)(parser, options?.DUPLICATE_POLICY);
+        (0, helpers_1.parseLabelsArgument)(parser, options?.LABELS);
+        (0, helpers_1.parseIgnoreArgument)(parser, options?.IGNORE);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CREATE.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/CREATERULE.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIME_SERIES_AGGREGATION_TYPE = void 0;
+exports.TIME_SERIES_AGGREGATION_TYPE = {
+    AVG: 'AVG',
+    FIRST: 'FIRST',
+    LAST: 'LAST',
+    MIN: 'MIN',
+    MAX: 'MAX',
+    SUM: 'SUM',
+    RANGE: 'RANGE',
+    COUNT: 'COUNT',
+    /**
+    * Available since 8.6
+    */
+    COUNT_NAN: 'COUNTNAN',
+    /**
+    * Available since 8.6
+    */
+    COUNT_ALL: 'COUNTALL',
+    STD_P: 'STD.P',
+    STD_S: 'STD.S',
+    VAR_P: 'VAR.P',
+    VAR_S: 'VAR.S',
+    TWA: 'TWA'
+};
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Creates a compaction rule from source time series to destination time series
+     * @param parser - The command parser
+     * @param sourceKey - The source time series key
+     * @param destinationKey - The destination time series key
+     * @param aggregationType - The aggregation type to use
+     * @param bucketDuration - The duration of each bucket in milliseconds
+     * @param alignTimestamp - Optional timestamp for alignment
+     */
+    parseCommand(parser, sourceKey, destinationKey, aggregationType, bucketDuration, alignTimestamp) {
+        parser.push('TS.CREATERULE');
+        parser.pushKeys([sourceKey, destinationKey]);
+        parser.push('AGGREGATION', aggregationType, bucketDuration.toString());
+        if (alignTimestamp !== undefined) {
+            parser.push(alignTimestamp.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=CREATERULE.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/DECRBY.js

@@ -0,0 +1,40 @@
+"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 INCRBY_1 = __importStar(require("./INCRBY"));
+exports.default = {
+    IS_READ_ONLY: INCRBY_1.default.IS_READ_ONLY,
+    /**
+     * Decreases the value of a time series by a given amount
+     * @param args - Arguments passed to the parseIncrByArguments function
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.DECRBY');
+        (0, INCRBY_1.parseIncrByArguments)(...args);
+    },
+    transformReply: INCRBY_1.default.transformReply
+};
+//# sourceMappingURL=DECRBY.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/DEL.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Deletes samples between two timestamps from a time series
+     * @param parser - The command parser
+     * @param key - The key name of the time series
+     * @param fromTimestamp - Start timestamp to delete from
+     * @param toTimestamp - End timestamp to delete until
+     */
+    parseCommand(parser, key, fromTimestamp, toTimestamp) {
+        parser.push('TS.DEL');
+        parser.pushKey(key);
+        parser.push((0, helpers_1.transformTimestampArgument)(fromTimestamp), (0, helpers_1.transformTimestampArgument)(toTimestamp));
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DEL.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/DELETERULE.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Deletes a compaction rule between source and destination time series
+     * @param parser - The command parser
+     * @param sourceKey - The source time series key
+     * @param destinationKey - The destination time series key
+     */
+    parseCommand(parser, sourceKey, destinationKey) {
+        parser.push('TS.DELETERULE');
+        parser.pushKeys([sourceKey, destinationKey]);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=DELETERULE.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/GET.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Gets the last sample of a time series
+     * @param parser - The command parser
+     * @param key - The key name of the time series
+     * @param options - Optional parameters for the command
+     */
+    parseCommand(parser, key, options) {
+        parser.push('TS.GET');
+        parser.pushKey(key);
+        if (options?.LATEST) {
+            parser.push('LATEST');
+        }
+    },
+    transformReply: {
+        2(reply) {
+            return reply.length === 0 ? null : {
+                timestamp: reply[0],
+                value: Number(reply[1])
+            };
+        },
+        3(reply) {
+            return reply.length === 0 ? null : {
+                timestamp: reply[0],
+                value: reply[1]
+            };
+        }
+    }
+};
+//# sourceMappingURL=GET.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/INCRBY.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIncrByArguments = void 0;
+const helpers_1 = require("./helpers");
+/**
+ * Parses arguments for incrementing a time series value
+ * @param parser - The command parser
+ * @param key - The key name of the time series
+ * @param value - The value to increment by
+ * @param options - Optional parameters for the command
+ */
+function parseIncrByArguments(parser, key, value, options) {
+    parser.pushKey(key);
+    parser.push(value.toString());
+    if (options?.TIMESTAMP !== undefined && options?.TIMESTAMP !== null) {
+        parser.push('TIMESTAMP', (0, helpers_1.transformTimestampArgument)(options.TIMESTAMP));
+    }
+    (0, helpers_1.parseRetentionArgument)(parser, options?.RETENTION);
+    if (options?.UNCOMPRESSED) {
+        parser.push('UNCOMPRESSED');
+    }
+    (0, helpers_1.parseChunkSizeArgument)(parser, options?.CHUNK_SIZE);
+    (0, helpers_1.parseLabelsArgument)(parser, options?.LABELS);
+    (0, helpers_1.parseIgnoreArgument)(parser, options?.IGNORE);
+}
+exports.parseIncrByArguments = parseIncrByArguments;
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Increases the value of a time series by a given amount
+     * @param args - Arguments passed to the {@link parseIncrByArguments} function
+     */
+    parseCommand(...args) {
+        const parser = args[0];
+        parser.push('TS.INCRBY');
+        parseIncrByArguments(...args);
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=INCRBY.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/INFO.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generic_transformers_1 = require("@redis/client/dist/lib/commands/generic-transformers");
+exports.default = {
+    IS_READ_ONLY: true,
+    /**
+     * Gets information about a time series
+     * @param parser - The command parser
+     * @param key - The key name of the time series
+     */
+    parseCommand(parser, key) {
+        parser.push('TS.INFO');
+        parser.pushKey(key);
+    },
+    transformReply: {
+        2: (reply, _, typeMapping) => {
+            const ret = {};
+            for (let i = 0; i < reply.length; i += 2) {
+                const key = reply[i].toString();
+                switch (key) {
+                    case 'totalSamples':
+                    case 'memoryUsage':
+                    case 'firstTimestamp':
+                    case 'lastTimestamp':
+                    case 'retentionTime':
+                    case 'chunkCount':
+                    case 'chunkSize':
+                    case 'chunkType':
+                    case 'duplicatePolicy':
+                    case 'sourceKey':
+                    case 'ignoreMaxTimeDiff':
+                        ret[key] = reply[i + 1];
+                        break;
+                    case 'labels':
+                        ret[key] = reply[i + 1].map(([name, value]) => ({
+                            name,
+                            value
+                        }));
+                        break;
+                    case 'rules':
+                        ret[key] = reply[i + 1].map(([key, timeBucket, aggregationType]) => ({
+                            key,
+                            timeBucket,
+                            aggregationType
+                        }));
+                        break;
+                    case 'ignoreMaxValDiff':
+                        ret[key] = generic_transformers_1.transformDoubleReply[2](reply[27], undefined, typeMapping);
+                        break;
+                }
+            }
+            return ret;
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+//# sourceMappingURL=INFO.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/INFO_DEBUG.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const INFO_1 = __importDefault(require("./INFO"));
+exports.default = {
+    IS_READ_ONLY: INFO_1.default.IS_READ_ONLY,
+    /**
+     * Gets debug information about a time series
+     * @param parser - The command parser
+     * @param key - The key name of the time series
+     */
+    parseCommand(parser, key) {
+        INFO_1.default.parseCommand(parser, key);
+        parser.push('DEBUG');
+    },
+    transformReply: {
+        2: (reply, _, typeMapping) => {
+            const ret = INFO_1.default.transformReply[2](reply, _, typeMapping);
+            for (let i = 0; i < reply.length; i += 2) {
+                const key = reply[i].toString();
+                switch (key) {
+                    case 'keySelfName': {
+                        ret[key] = reply[i + 1];
+                        break;
+                    }
+                    case 'Chunks': {
+                        ret['chunks'] = reply[i + 1].map(chunk => ({
+                            startTimestamp: chunk[1],
+                            endTimestamp: chunk[3],
+                            samples: chunk[5],
+                            size: chunk[7],
+                            bytesPerSample: chunk[9]
+                        }));
+                        break;
+                    }
+                }
+            }
+            return ret;
+        },
+        3: undefined
+    },
+    unstableResp3: true
+};
+//# sourceMappingURL=INFO_DEBUG.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/MADD.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_1 = require("./helpers");
+exports.default = {
+    IS_READ_ONLY: false,
+    /**
+     * Adds multiple samples to multiple time series
+     * @param parser - The command parser
+     * @param toAdd - Array of samples to add to different time series
+     */
+    parseCommand(parser, toAdd) {
+        parser.push('TS.MADD');
+        for (const { key, timestamp, value } of toAdd) {
+            parser.pushKey(key);
+            parser.push((0, helpers_1.transformTimestampArgument)(timestamp), value.toString());
+        }
+    },
+    transformReply: undefined
+};
+//# sourceMappingURL=MADD.js.map

package/.output/server/node_modules/@redis/time-series/dist/lib/commands/MGET.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFilterArgument = exports.parseLatestArgument = void 0;
+const helpers_1 = require("./helpers");
+/**
+ * Adds LATEST argument to command if specified
+ * @param parser - The command parser
+ * @param latest - Whether to include the LATEST argument
+ */
+function parseLatestArgument(parser, latest) {
+    if (latest) {
+        parser.push('LATEST');
+    }
+}
+exports.parseLatestArgument = parseLatestArgument;
+/**
+ * Adds FILTER argument to command
+ * @param parser - The command parser
+ * @param filter - Filter to match time series keys
+ */
+function parseFilterArgument(parser, filter) {
+    parser.push('FILTER');
+    parser.pushVariadic(filter);
+}
+exports.parseFilterArgument = parseFilterArgument;
+exports.default = {
+    NOT_KEYED_COMMAND: true,
+    IS_READ_ONLY: true,
+    /**
+     * Gets the last samples matching a specific filter from multiple time series
+     * @param parser - The command parser
+     * @param filter - Filter to match time series keys
+     * @param options - Optional parameters for the command
+     */
+    parseCommand(parser, filter, options) {
+        parser.push('TS.MGET');
+        parseLatestArgument(parser, options?.LATEST);
+        parseFilterArgument(parser, filter);
+    },
+    transformReply: {
+        2(reply, _, typeMapping) {
+            return (0, helpers_1.resp2MapToValue)(reply, ([, , sample]) => {
+                return {
+                    sample: helpers_1.transformSampleReply[2](sample)
+                };
+            }, typeMapping);
+        },
+        3(reply) {
+            return (0, helpers_1.resp3MapToValue)(reply, ([, sample]) => {
+                return {
+                    sample: helpers_1.transformSampleReply[3](sample)
+                };
+            });
+        }
+    }
+};
+//# sourceMappingURL=MGET.js.map